线程锁Lock

              Lock是一个接口，知道这个哪些实现类

                 

        查看接口实现类通过

                     

    在上锁后，只有上锁这部分代码执行完后其他线程才可以执行上锁的代码块

lock.lock();  

    代码块

  lock.unlock();

 

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


public class LockTest {
      

public static void main(String[] args) {
 final Lock lock = new  ReentrantLock();
new Thread(new Runnable() {

@Override
public void run() {
lock.lock();
try{
          for(int i=0;i<100;i++){ 
          System.out.println("-a");
          }
}finally{
lock.unlock();
}
     
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
lock.lock();
try{
          for(int i=100;i<310;i++){ 
          System.out.println("-b");
          }
}finally{
lock.unlock();
}
}
}).start();
 
}
}

输出：

-a
-a
-a

..
-b
-b
-b
-b
-b
-b
-b

...    

分析：只有输出a的线程执行完毕后，解锁后，输出b的线程才可以执行输出b

   读写锁

  final ReadWriteLocklock = new  ReentrantReadWriteLock();

要点：

读与读  不互斥

读与写  互斥

写与写  互斥

public class LockTest {
public static void main(String[] args) {
 final ReadWriteLock lock = new  ReentrantReadWriteLock();
new Thread(new Runnable() {
@Override
public void run() {
lock.readLock().lock();

try{
          for(int i=0;i<3;i++){ 
          printz("a");
          }
          try {
Thread.sleep(10000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}finally{
lock.readLock().unlock();
}

     
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
lock.readLock().lock();;
try{
          for(int i=0;i<3;i++){ 
          printz("-b");
          }
}finally{
lock.readLock().unlock();
}
}
}).start();

}
public static void   printz(String s){
System.out.print(s);
}
}

由于读锁与读锁不互斥，所以aaa -b-b-b都会同时输出不会等待A线程休眠3秒后在输出bbb;

如果改为读锁与写锁，则先输出aaa等3秒后A线程结束不互斥后B线程开始输出bbb;