1ReentrantLock实现同步
package service; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class MyService { private Lock lock=new ReentrantLock(); public void testMethod(){ lock.lock(); for(int i=0;i<5;i++){ System.out.println("ThreadName="+Thread.currentThread().getName()+(" "+(i+1))); } lock.unlock(); } } package service; public class MyThread extends Thread{ private MyService service; public MyThread(MyService service){ super(); this.service=service; } @Override public void run(){ service.testMethod(); } }2借助Condition对象实现等待/通知模式 在使用notify()/notifyAll()方法进行通知时，被通知的线程是由JVM随机选择的；使用ReentrantLock结合Condition类可以实现“选择性通知”。synchronized相当于整个Lock对象只有一个Condition对象，所有线程都注册在这一个对象上。 object类中的wait()方法相当于Condition类的await()方法 object.wait(long timeout) condition.await(long time,TimeUnit unit) object.notify() condition.signal() object.notifyAll() condition.signalAll()
package service; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.ReentrantLock; public class MyService { private ReentrantLock lock=new ReentrantLock(); private Condition conditionA=lock.newCondition(); private Condition conditionB=lock.newCondition(); private boolean hasValue=false; public void set(){ try{ lock.lock(); while(hasValue==true){ System.out.println("有可能**连续"); conditionA.await(); } System.out.println("打印*"); hasValue=true; conditionB.signal(); }catch(InterruptedException e){ e.printStackTrace(); }finally{ lock.unlock(); } } public void get(){ try{ lock.lock(); while(hasValue==false){ System.out.println("有可能&&连续"); conditionB.await(); } System.out.println("打印&"); hasValue=false; conditionA.signal(); }catch(InterruptedException e){ e.printStackTrace(); }finally{ lock.unlock(); } } } package service; public class MyThreadA extends Thread{ private MyService myService; public MyThreadA(MyService myService){ super(); this.myService=myService; } @Override public void run(){ for(int i=0;i<Integer.MAX_VALUE;i++){ myService.set(); } } } package service; public class MyThreadB extends Thread{ private MyService myService; public MyThreadB(MyService myService){ super(); this.myService=myService; } @Override public void run(){ for(int i=0;i<Integer.MAX_VALUE;i++){ myService.get(); } } } package service; public class Run { public static void main(String[] args){ MyService service=new MyService(); MyThreadA[] threadA=new MyThreadA[10]; MyThreadB[] threadB=new MyThreadB[10]; for(int i=0;i<10;i++){ threadA[i]=new MyThreadA(service); threadB[i]=new MyThreadB(service); threadA[i].start(); threadB[i].start(); } } }3公平锁和非公平锁 公平锁表示线程获取锁的顺序是按线程加锁的顺序执行的，非公平锁是一种抢占机制，是随机获得锁的，可能某个线程一直拿不到锁，结果也就是不公平的。ReentrantLock默认情况下是非公平锁。 ReentrantLock lock=new ReentrantLock(true);//公平锁
4ReentrantReadWriteLock读写锁 读写锁有两个锁，一个是读操作相关的锁，也称为共享锁；另一个是写操作相关的锁，也叫排它锁。多个读锁之间不互斥，读锁与写锁互斥，写锁与写锁互斥
package service; import java.util.concurrent.locks.ReentrantReadWriteLock; public class Service { private ReentrantReadWriteLock lock=new ReentrantReadWriteLock(); public void read(){ try{ try{ lock.readLock().lock(); System.out.println("获得读锁"); Thread.sleep(10000); }finally{ lock.readLock().unlock(); } }catch(InterruptedException e){ e.printStackTrace(); } } public void write(){ try{ try{ lock.writeLock().lock(); System.out.println("获得写锁"); Thread.sleep(10000); }finally{ lock.writeLock().unlock(); } }catch(InterruptedException e){ e.printStackTrace(); } } }