Java线程读写锁
排他锁和共享锁：
读写锁：既是排他锁，又是共享锁。读锁，共享锁，写锁：排他锁
读和读是不互斥的
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class Demo {
private Map<String, Object> map=new HashMap<>();
private ReadWriteLock rwl=new ReentrantReadWriteLock();
private Lock r=rwl.readLock();
private Lock w=rwl.writeLock();
public Object get(String key){
r.lock();
System.out.println(Thread.currentThread().getName()+"读操作正在执行。。。");
try {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return map.get(key);
} finally{
r.unlock();
System.out.println(Thread.currentThread().getId()+"读操作执行完毕。。。");
}
}
public void put(String key,Object value){
w.lock();
System.out.println(Thread.currentThread().getName()+"写操作在执行。。。");
try {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
map.put(key, value);
} finally {
w.unlock();
System.out.println(Thread.currentThread().getName()+"写操作执行完毕。。。");
}
}
}
public class Main {
public static void main(String[] args) {
Demo d=new Demo();
d.put("key1", "value1");
// new Thread(new Runnable() {
// @Override
// public void run() {
// d.put("key1", "value1");
// }
// }).start();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(d.get("key1"));
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(d.get("key1"));
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(d.get("key1"));
}
}).start();
// new Thread(new Runnable() {
// @Override
// public void run() {
// d.put("key3", "value3");
// }
// }).start();
}
}
读写锁需要保存的状态：
写锁重入的次数
读锁的个数
每个读锁重入的次数
锁降级：是指写锁降为读锁
在写锁没有释放的时候，获取到读锁，在释放写锁
锁升级：
把读锁，升级为写锁
在读锁没有释放的时候，获取到写锁，在释放读锁
private volatile boolean isUpdate;
public void readWrite(){
r.lock();
if(isUpdate){
r.unlock();
w.lock();
map.put("XXX", "xxx");
r.lock();
w.unlock();
}
Object obj=map.get("XXX");
System.out.println(obj);
r.unlock();
}
出现线程安全性问题的条件
1.必须在多线程的环境下
2.必须有共享资源
3.对共享资源进行非原子性操作
解决线程安全性问题的途径
1.synchronized 相对慢（偏向锁、轻量级锁、重量级锁）
2.volatile（只能保证读写操作，不能保证非原子性操作）
3.JDK提供的原子类
4.使用Lock（共享锁、排它锁）
认识的“*锁“
1.偏向锁
2.轻量级锁
3.重量级锁
4.重入锁
5.自旋锁
6.共享锁
7.独占锁
8.排它锁
9.读写锁
10.公平锁
11.非公平锁
12.死锁
13.活锁
public class Tmall {
public int count;
public final int MAX_COUNT=10;
public synchronized void push(){
while(count>=MAX_COUNT)
try {
System.out.println(Thread.currentThread().getName()+
"库存数量达到上限，生产者停止生产。");
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
count++;
System.out.println(Thread.currentThread().getName()
+"生产者生产，当前库存为："+count);
notify();
}
public synchronized void task(){
while(count<=0)
try {
System.out.println(Thread.currentThread().getName()+
"库存数量为零，消费着等待。");
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
count--;
System.out.println(Thread.currentThread().getName()+
"消费者消费，当前库存为："+count);
notify();
}
}
public class TaskTarget implements Runnable {
private Tmall tmall;
public TaskTarget(Tmall tmall) {
this.tmall=tmall;
}
@Override
public void run() {
tmall.task();
}
}
public class PushTarget implements Runnable{
private Tmall tmall;
public PushTarget(Tmall tmall) {
this.tmall=tmall;
}
@Override
public void run() {
while(true){
tmall.push();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class Main {
public static void main(String[] args){
Tmall tmall=new Tmall();
PushTarget p=new PushTarget(tmall);
TaskTarget t=new TaskTarget(tmall);
new Thread(p).start();
new Thread(p).start();
new Thread(p).start();
new Thread(t).start();
new Thread(t).start();
new Thread(t).start();
}
}
Condition的使用。
public class Demo5 {
private int signal;
//执行顺序 a->b->c
public synchronized void a(){
while(signal!=0){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("a");
signal++;
notifyAll();
}
public synchronized void b(){
while(signal!=1){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("b");
signal++;
notifyAll();
}
public synchronized void c(){
while(signal!=2){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("c");
signal=0;
notifyAll();
}
public static void main(String[] args){
Demo5 d=new Demo5();
A a=new A(d);
B b=new B(d);
C c=new C(d);
new Thread(a).start();
new Thread(b).start();
new Thread(c).start();
}
}
class A implements Runnable{
private Demo5 demo;
public A(Demo5 demo){
this.demo=demo;
}
@Override
public void run(){
while(true){
demo.a();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class B implements Runnable{
private Demo5 demo;
public B(Demo5 demo){
this.demo=demo;
}
@Override
public void run(){
while(true){
demo.b();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class C implements Runnable{
private Demo5 demo;
public C(Demo5 demo){
this.demo=demo;
}
@Override
public void run(){
while(true){
demo.c();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
用condition
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Demo {
private int signal;
Lock lock = new ReentrantLock();
Condition a = lock.newCondition();
Condition b = lock.newCondition();
Condition c = lock.newCondition();
public void a() {
lock.lock();
while(signal != 0 ) {
try {
a.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("a");
signal ++;
b.signal();
lock.unlock();
}
public void b() {
lock.lock();
while(signal != 1) {
try {
b.await();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println("b");
signal ++;
c.signal();
lock.unlock();
}
public void c () {
lock.lock();
while(signal != 2) {
try {
c.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("c");
signal = 0;
a.signal();
lock.unlock();
}
public static void main(String[] args) {
Demo d = new Demo();
A a = new A(d);
B b = new B(d);
C c = new C(d);
new Thread(a).start();
new Thread(b).start();
new Thread(c).start();
}
}
class A implements Runnable {
private Demo demo;
public A(Demo demo) {
this.demo = demo;
}
@Override
public void run() {
while(true) {
demo.a();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class B implements Runnable {
private Demo demo;
public B(Demo demo) {
this.demo = demo;
}
@Override
public void run() {
while(true) {
demo.b();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class C implements Runnable {
private Demo demo;
public C(Demo demo) {
this.demo = demo;
}
@Override
public void run() {
while(true) {
demo.c();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
实现一个队列：
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class MyQueue<E> {
private Object[] obj;
private int addIndex;
private int removeIndex;
private int queueSize;
private Lock lock=new ReentrantLock();
Condition addCondition=lock.newCondition();
Condition removeCondition=lock.newCondition();
public MyQueue(int count){
obj=new Object[count];
}
public void add(E e){
lock.lock();
//满了之后等待
while(queueSize==obj.length){
try {
addCondition.await();
} catch (InterruptedException e1) {
e1.printStackTrace();
}
}
obj[addIndex]=e;
if(++addIndex==obj.length){ //先比较在++
addIndex=0;
}
queueSize++;
removeCondition.signal();
lock.unlock();
}
public void remove(){
lock.lock();
while (queueSize==0) {
try {
removeCondition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
obj[removeIndex]=null;
if(++removeIndex==obj.length){
removeIndex=0;
}
queueSize--;
addCondition.signal();
lock.unlock();
}
}
