线程同步
多线程之间调用同一对象时，为了运行的安全和准确性，需要对该对象进行同步，确保每一个线程用到的时候该对象的结果都是正确的，该对象的状态都是合理的，这部分涉及到同步、线程锁等知识点。这部分的只是就涉及到了synchronized、同步锁（Lock）的概念。
synchronized
synchronized关键词可以修饰对象、方法，通常用法如下：
//同步代码块synchronized（Object object）{...}//或者//同步方法public synchronized void test(){...}
其中有一个同步监视器的概念，比如上面同步代码块的object对象以及同步方法的this对象就会同步监视，多个线程同时调用一个同步的代码块或者方法时，在任何时刻只能够一个线程能够获得该同步监视的对象锁，执行完代码之后才会释放该锁，在此期间其他调用的线程只能等待该锁被释放后才能调用。
上文中提到的SellRunnable类中的sell方法也用到了synchronized，上文中代码执行太快，所以感知不到，如果修改一下就能明白有没有synchronized的区别了。
public class ThreadTest { public static void main(String[] args) { SellRunnable sellRunnable = new SellRunnable(); Thread thread1 = new Thread(sellRunnable, "1"); Thread thread2 = new Thread(sellRunnable, "2"); Thread thread3 = new Thread(sellRunnable, "3"); thread2.start(); thread1.start(); thread3.start(); }}class SellRunnable implements Runnable { //有十张票 int index = 10; public void sell() { if (index >= 1) { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } index--; System.out.println("售货窗口：" + Thread.currentThread().getName() + " 卖出了一张票,剩余： " + index); } else { System.out.println("售货窗口：" + Thread.currentThread().getName() + " 买票时没票了"); } } @Override public void run() { while (index > 0) { System.out.println("售货窗口：" + Thread.currentThread().getName() + " 开始买票"); sell(); } }}//执行结果：售货窗口：1 开始买票售货窗口：2 开始买票售货窗口：3 开始买票售货窗口：2 卖出了一张票,剩余：9售货窗口：2 开始买票售货窗口：1 卖出了一张票,剩余：9售货窗口：1 开始买票售货窗口：3 卖出了一张票,剩余：8售货窗口：3 开始买票售货窗口：1 卖出了一张票,剩余：6售货窗口：1 开始买票售货窗口：2 卖出了一张票,剩余：6售货窗口：2 开始买票售货窗口：3 卖出了一张票,剩余：5售货窗口：3 开始买票售货窗口：1 卖出了一张票,剩余：4售货窗口：1 开始买票售货窗口：2 卖出了一张票,剩余：3售货窗口：3 卖出了一张票,剩余：2售货窗口：3 开始买票售货窗口：2 开始买票售货窗口：3 卖出了一张票,剩余：1售货窗口：2 卖出了一张票,剩余：0售货窗口：1 卖出了一张票,剩余：1Process finished with exit code 0 //可以看到，票数减少是错误的//sell方法添加synchronized修饰符后 执行结果：public synchronized void sell() { if (index >= 1) { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } index--; System.out.println("售货窗口：" + Thread.currentThread().getName() + " 卖出了一张票,剩余： " + index); } else { System.out.println("售货窗口：" + Thread.currentThread().getName() + " 买票时没票了"); } }售货窗口：2 开始买票售货窗口：3 开始买票售货窗口：1 开始买票售货窗口：2 卖出了一张票,剩余：9售货窗口：2 开始买票售货窗口：1 卖出了一张票,剩余：8售货窗口：1 开始买票售货窗口：3 卖出了一张票,剩余：7售货窗口：3 开始买票售货窗口：1 卖出了一张票,剩余：6售货窗口：1 开始买票售货窗口：2 卖出了一张票,剩余：5售货窗口：2 开始买票售货窗口：1 卖出了一张票,剩余：4售货窗口：1 开始买票售货窗口：1 卖出了一张票,剩余：3售货窗口：1 开始买票售货窗口：3 卖出了一张票,剩余：2售货窗口：3 开始买票售货窗口：1 卖出了一张票,剩余：1售货窗口：1 开始买票售货窗口：1 卖出了一张票,剩余：0售货窗口：2 买票时没票了售货窗口：3 买票时没票了Process finished with exit code 0 // 可以看到，票数是正常减少的
以上对于sell方法进行同步之后，在某一瞬间，只会有一个线程调用该方法，所以里面判断index的时候得到的结果就是正确的结果。
以上同步的时候，是以降低运行效率的方式来保证线程安全的，为此，不要对线程使用类中没必要的方法、对象进行同步标识，只对有竞争的资源或者代码进行同步标识。
同步标识后，有以下几点可以释放该锁：
代码块、方法执行完毕（正常完毕、return或break、抛出异常）
调用了wait方法，使得当前线程暂停。
当线程执行到同步代码块时，sleep、yield方法不会释放该同步锁，挂起方法suspend也不会（线程操作过程中尽量避免使用suspend、resume来操作线程状态，容易导致死锁。）
同步锁Lock
上文中提到的synchronized是java中的一个关键词，也提到了在sleep的时候、进行IO操作的时候该线程不会释放线程锁，其他线程就需要一直等待，这样有时会降低执行的效率，所以就需要一个可以在线程阻塞时可以释放线程锁的替代方案，Lock就是为了解决这个问题出现的。
Lock是一个java中的类，在java.util.concurrent.locks包中，具体的代码如下：
public interface Lock { void lock();//加锁 void lockInterruptibly() throws InterruptedException;//加锁 boolean tryLock();//加锁 boolean tryLock(long time, TimeUnit unit) throws InterruptedException;//加锁 void unlock();//释放锁 Condition newCondition();//线程协作中用到}
Lock接口的一个实现子类为ReentrantLock，在java.util.concurrent.locks包下，ReentrantLock的源代码如下：
public class ReentrantLock implements Lock, Serializable { private static final long serialVersionUID = 7373984872572414699L; private final ReentrantLock.Sync sync; public ReentrantLock() { this.sync = new ReentrantLock.NonfairSync(); } public ReentrantLock(boolean var1) {//是否创建公平锁 this.sync = (ReentrantLock.Sync)(var1?new ReentrantLock.FairSync():new ReentrantLock. NonfairSync()); } public void lock() { this.sync.lock(); } public void lockInterruptibly() throws InterruptedException { this.sync.acquireInterruptibly(1); } public boolean tryLock() { return this.sync.nonfairTryAcquire(1); } public boolean tryLock(long var1, TimeUnit var3) throws InterruptedException { return this.sync.tryAcquireNanos(1, var3.toNanos(var1)); } public void unlock() { this.sync.release(1); } public Condition newCondition() { return this.sync.newCondition(); } public int getHoldCount() {//当前线程持有该锁的数量 return this.sync.getHoldCount(); } public boolean isHeldByCurrentThread() {//该锁是否被当前线程持有 return this.sync.isHeldExclusively(); } public boolean isLocked() {//是否被其他线程持有该锁 return this.sync.isLocked(); } public final boolean isFair() {//是否是公平锁 return this.sync instanceof ReentrantLock.FairSync; } protected Thread getOwner() {//当前锁的持有线程 return this.sync.getOwner(); } public final boolean hasQueuedThreads() {//是否有线程在等待该锁 return this.sync.hasQueuedThreads(); } public final boolean hasQueuedThread(Thread var1) {//目标线程是否在等待该锁 return this.sync.isQueued(var1); } public final int getQueueLength() {//等待该锁线程的数量 return this.sync.getQueueLength(); } protected Collection<Thread> getQueuedThreads() {//获取所有等待该锁的线程集合 return this.sync.getQueuedThreads(); } ... }
Lock的使用方法
lock
lock() 用来获取锁，如果该锁被其他线程占用，则进入等待。
public class LockTest { public static void main(String[] args) { com.test.java.SellRunnable sellRunnable = new com.test.java.SellRunnable(); Thread thread1 = new Thread(sellRunnable, "1号窗口"); Thread thread2 = new Thread(sellRunnable, "2号窗口"); Thread thread3 = new Thread(sellRunnable, "3号窗口"); thread1.start(); thread2.start(); thread3.start(); }}
public class SellRunnable implements Runnable { //有十张票 int index = 10; Lock lock = new ReentrantLock(); public void sell() { try { lock.lock(); System.out.println("售货柜台：" + Thread.currentThread().getName() + "获取了票源+++++"); if (index >= 1) { index--; System.out.println("售货柜台：" + Thread.currentThread().getName() + "卖出了一张票,剩余： " + index); } else { System.out.println("售货柜台：" + Thread.currentThread().getName() + "买票时没票了000"); } } finally { lock.unlock(); } } @Override public void run() { while (index > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } sell(); } }}
运行结果：
售货柜台：3号窗口获取了票源+++++售货柜台：3号窗口卖出了一张票,剩余：9售货柜台：1号窗口获取了票源+++++售货柜台：1号窗口卖出了一张票,剩余：8售货柜台：2号窗口获取了票源+++++售货柜台：2号窗口卖出了一张票,剩余：7售货柜台：1号窗口获取了票源+++++售货柜台：1号窗口卖出了一张票,剩余：6售货柜台：3号窗口获取了票源+++++售货柜台：3号窗口卖出了一张票,剩余：5售货柜台：2号窗口获取了票源+++++售货柜台：2号窗口卖出了一张票,剩余：4售货柜台：3号窗口获取了票源+++++售货柜台：3号窗口卖出了一张票,剩余：3售货柜台：1号窗口获取了票源+++++售货柜台：1号窗口卖出了一张票,剩余：2售货柜台：2号窗口获取了票源+++++售货柜台：2号窗口卖出了一张票,剩余：1售货柜台：3号窗口获取了票源+++++售货柜台：3号窗口卖出了一张票,剩余：0售货柜台：1号窗口获取了票源+++++售货柜台：1号窗口买票时没票了000售货柜台：2号窗口获取了票源+++++售货柜台：2号窗口买票时没票了000Process finished with exit code 0 //每一个窗口都随机获取票源、然后卖出票
tryLock
tryLock()尝试获取锁，如果获取成功返回true，如果失败，则返回false，不会进入等待状态。
public class SellRunnable implements Runnable { //有十张票 int index = 10; Lock lock = new ReentrantLock(); public void sell() { if (lock.tryLock()) { try { System.out.println("售货柜台：" + Thread.currentThread().getName() + "获取了票源+++++"); if (index >= 1) { index--; System.out.println("售货柜台：" + Thread.currentThread().getName() + "卖出了一张票,剩余：" + index); } else { System.out.println("售货柜台：" + Thread.currentThread().getName() + "买票时没票了000"); } } finally { lock.unlock(); } } else { System.out.println("售货柜台：" + Thread.currentThread().getName()+"没有获取票源！！！"); } } @Override public void run() { while (index > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } sell(); } }}
运行结果：
售货柜台：1号窗口获取了票源+++++售货柜台：3号窗口没有获取票源！！！售货柜台：2号窗口没有获取票源！！！售货柜台：1号窗口卖出了一张票,剩余：9售货柜台：2号窗口没有获取票源！！！售货柜台：3号窗口获取了票源+++++售货柜台：3号窗口卖出了一张票,剩余：8售货柜台：1号窗口获取了票源+++++售货柜台：1号窗口卖出了一张票,剩余：7售货柜台：1号窗口没有获取票源！！！售货柜台：3号窗口没有获取票源！！！售货柜台：2号窗口获取了票源+++++售货柜台：2号窗口卖出了一张票,剩余：6售货柜台：1号窗口获取了票源+++++售货柜台：2号窗口没有获取票源！！！售货柜台：3号窗口没有获取票源！！！售货柜台：1号窗口卖出了一张票,剩余：5售货柜台：2号窗口获取了票源+++++售货柜台：1号窗口没有获取票源！！！售货柜台：2号窗口卖出了一张票,剩余：4售货柜台：3号窗口没有获取票源！！！售货柜台：1号窗口获取了票源+++++售货柜台：2号窗口没有获取票源！！！售货柜台：3号窗口没有获取票源！！！售货柜台：1号窗口卖出了一张票,剩余：3售货柜台：1号窗口获取了票源+++++售货柜台：1号窗口卖出了一张票,剩余：2售货柜台：2号窗口获取了票源+++++售货柜台：3号窗口没有获取票源！！！售货柜台：2号窗口卖出了一张票,剩余：1售货柜台：1号窗口获取了票源+++++售货柜台：1号窗口卖出了一张票,剩余：0售货柜台：3号窗口没有获取票源！！！售货柜台：2号窗口没有获取票源！！！Process finished with exit code 0//没有获取到货源的票口，就直接没有等待，进入下次买票
tryLock(long time, TimeUnit unit)
tryLock(long time, TimeUnit unit)可以设置拿不到锁的时候等待一段时间。//第一个参数时常长，第二个参数时间单位
public class SellRunnable implements Runnable { //有十张票 int index = 10; Lock lock = new ReentrantLock(); public void sell() { try { if (lock.tryLock(1000, TimeUnit.MILLISECONDS)) { try { System.out.println("售货柜台：" + Thread.currentThread().getName() + "获取了票源+++++"); if (index >= 1) { index--; System.out.println("售货柜台：" + Thread.currentThread().getName() +"卖出了一张票,剩余：" + index); } else { System.out.println("售货柜台：" + Thread.currentThread(). getName() + "买票时没票了000"); } try { Thread.sleep(2000);//人为加入买票时间 } catch (InterruptedException e) { e.printStackTrace(); } } finally { lock.unlock(); } } else { System.out.println("售货柜台：" + Thread.currentThread().getName() + "没有获取票源！！！"); } } catch (InterruptedException e) { e.printStackTrace(); } } @Override public void run() { while (index > 0) { try { Thread.sleep(500);//要不执行太快，看不出效果 } catch (InterruptedException e) { e.printStackTrace(); } sell(); } }}
执行结果：
售货柜台：1号窗口获取了票源+++++售货柜台：1号窗口卖出了一张票,剩余：9售货柜台：2号窗口没有获取票源！！！售货柜台：3号窗口没有获取票源！！！售货柜台：2号窗口获取了票源+++++售货柜台：2号窗口卖出了一张票,剩余：8售货柜台：3号窗口没有获取票源！！！售货柜台：1号窗口没有获取票源！！！售货柜台：3号窗口获取了票源+++++售货柜台：3号窗口卖出了一张票,剩余：7售货柜台：1号窗口没有获取票源！！！售货柜台：2号窗口没有获取票源！！！售货柜台：1号窗口获取了票源+++++售货柜台：1号窗口卖出了一张票,剩余：6售货柜台：2号窗口没有获取票源！！！售货柜台：3号窗口没有获取票源！！！售货柜台：2号窗口获取了票源+++++售货柜台：2号窗口卖出了一张票,剩余：5售货柜台：3号窗口没有获取票源！！！售货柜台：1号窗口没有获取票源！！！售货柜台：3号窗口获取了票源+++++售货柜台：3号窗口卖出了一张票,剩余：4售货柜台：1号窗口没有获取票源！！！售货柜台：2号窗口没有获取票源！！！售货柜台：1号窗口获取了票源+++++售货柜台：1号窗口卖出了一张票,剩余：3售货柜台：2号窗口没有获取票源！！！售货柜台：3号窗口没有获取票源！！！售货柜台：2号窗口获取了票源+++++售货柜台：2号窗口卖出了一张票,剩余：2售货柜台：3号窗口没有获取票源！！！售货柜台：1号窗口没有获取票源！！！售货柜台：3号窗口获取了票源+++++售货柜台：3号窗口卖出了一张票,剩余：1售货柜台：1号窗口没有获取票源！！！售货柜台：2号窗口没有获取票源！！！售货柜台：1号窗口获取了票源+++++售货柜台：1号窗口卖出了一张票,剩余：0售货柜台：2号窗口没有获取票源！！！售货柜台：3号窗口没有获取票源！！！Process finished with exit code 0 //当买票时间大约等待时间时，则没有获取票源的窗口不买票，进入下个买票机会
将买票时间缩短：
try { Thread.sleep(500);//人为加入买票时间} catch (InterruptedException e) { e.printStackTrace();}
执行结果：
售货柜台：1号窗口获取了票源+++++售货柜台：1号窗口卖出了一张票,剩余：9售货柜台：2号窗口获取了票源+++++售货柜台：2号窗口卖出了一张票,剩余：8售货柜台：3号窗口没有获取票源！！！售货柜台：1号窗口获取了票源+++++售货柜台：1号窗口卖出了一张票,剩余：7售货柜台：2号窗口获取了票源+++++售货柜台：2号窗口卖出了一张票,剩余：6售货柜台：1号窗口获取了票源+++++售货柜台：1号窗口卖出了一张票,剩余：5售货柜台：3号窗口没有获取票源！！！售货柜台：2号窗口获取了票源+++++售货柜台：2号窗口卖出了一张票,剩余：4售货柜台：3号窗口获取了票源+++++售货柜台：3号窗口卖出了一张票,剩余：3售货柜台：1号窗口获取了票源+++++售货柜台：1号窗口卖出了一张票,剩余：2售货柜台：2号窗口获取了票源+++++售货柜台：2号窗口卖出了一张票,剩余：1售货柜台：3号窗口获取了票源+++++售货柜台：3号窗口卖出了一张票,剩余：0售货柜台：1号窗口获取了票源+++++售货柜台：1号窗口买票时没票了000售货柜台：2号窗口获取了票源+++++售货柜台：2号窗口买票时没票了000Process finished with exit code 0 //等待时间内获取到票源了，也就卖出票了
lockInterruptibly
lockInterruptibly()通过该方法获取锁时，如果该锁正在被其他线程持有，则进入等待状态，但是这个等待过程是可以被中断的，通过调用Thread对象的interrupt方法就可中断等待，中断时抛出异常InterruptedException，需要捕获或者声明抛出。
public class ThreadTest { public static void main(String[] args) { SellRunnable sellRunnable = new SellRunnable(); Thread thread1 = new Thread(sellRunnable, "1号窗口"); Thread thread2 = new Thread(sellRunnable, "2号窗口"); Thread thread3 = new Thread(sellRunnable, "3号窗口"); thread1.start(); try { Thread.sleep(500);//确保窗口1号先获取锁 } catch (InterruptedException e) { e.printStackTrace(); } thread2.start(); thread3.start(); try { Thread.sleep(2000);//等待两秒后，打断窗口2、3的等待 } catch (InterruptedException e) { e.printStackTrace(); } thread2.interrupt(); thread3.interrupt(); }}SellRunnable中等待时间加长：try { Thread.sleep(5000);//人为加入买票时间} catch (InterruptedException e) { e.printStackTrace();}
执行结果：
售货柜台：1号窗口获取了票源+++++售货柜台：1号窗口卖出了一张票,剩余：9售货柜台：3号窗口被打断了 //这个地方被打断了售货柜台：2号窗口被打断了 //这个地方被打断了售货柜台：2号窗口获取了票源+++++售货柜台：2号窗口卖出了一张票,剩余：8售货柜台：3号窗口获取了票源+++++售货柜台：3号窗口卖出了一张票,剩余：7售货柜台：1号窗口获取了票源+++++售货柜台：1号窗口卖出了一张票,剩余：6售货柜台：2号窗口获取了票源+++++售货柜台：2号窗口卖出了一张票,剩余：5售货柜台：3号窗口获取了票源+++++售货柜台：3号窗口卖出了一张票,剩余：4售货柜台：1号窗口获取了票源+++++售货柜台：1号窗口卖出了一张票,剩余：3售货柜台：2号窗口获取了票源+++++售货柜台：2号窗口卖出了一张票,剩余：2售货柜台：3号窗口获取了票源+++++售货柜台：3号窗口卖出了一张票,剩余：1售货柜台：1号窗口获取了票源+++++售货柜台：1号窗口卖出了一张票,剩余：0售货柜台：2号窗口获取了票源+++++售货柜台：2号窗口买票时没票了000售货柜台：3号窗口获取了票源+++++售货柜台：3号窗口买票时没票了000Process finished with exit code 0
synchronized和Lock对比
通过以上代码，可以看出Lock和synchronized的几点关联和区别：
两者都是可重入锁
可重入锁是指当一个线程获得对象锁之后，该线程可以再次获取该对象的锁而不被阻塞。比如同一个类中有多个方法（或一个方法递归调用）被synchronized修饰或者被Lock加持后，同一个线程在调用这两个方法时都可以获取该对象的锁而不被阻塞。
不可重入锁的示例：
public class Lock{ private boolean isLocked = false; public void lock(){ while(isLocked){ wait(); } isLocked = true; } public void unlock(){ isLocked = false; notify(); }}//使用方法：public class Test{ Lock lock = new Lock(); public void test1(){ lock.lock(); test2(); lock.unlock(); } public void test2(){ lock.lock(); ... lock.unlock(); }}
Test类在调用test1方法的时候，执行完lock.lock()后调用test2的时候，就会一直等待，变成死锁。
可重入锁设计原理：
public class Lock{ private boolean isLocked = false; private Thread lockedThread = null; int lockedCount = 0; public void lock(){ Thread thread = Thread.currentThread(); while(isLocked && thread != lockedThread){ wait(); } isLocked = true; lockedCount++; lockedThread = thread; } public void unlock(){ Thread thread = Thread.currentThread(); if(thread == lockedThread){ lockedCount--; if(lockedCount == 0){ isLocked = false; lockedThread = null; notify(); } } }}
这样调用Test类的test1方法后，test2方法也能顺利被执行。
synchronized在实现上也基本上是采用记数器的方式来实现可重入的。
Lock是可中断锁，synchronized不可中断。
当一个线程B执行被锁的对象的代码时，发现线程A已经持有该锁，那么线程B就会进入等待，但是synchronized就无法中断该等待过程，而Lock就可以通过lockInterruptibly方法抛出异常从而中断等待，去处理别的事情。
Lock可创建公平锁，synchronized是非公平锁。
公平锁的意思是按照请求的顺序来获取锁，不平公锁就无法保证线程获取锁的先后次序。
Lock可以知道是否获取到锁，synchronized不可以。
synchronized在发生异常或者运行完毕，会自动释放线程占有的锁。而Lock需要主动释放锁，否则会锁死；
synchronized在阻塞时，别的线程无法获取锁，Lock可以（这也是lock设计的一个目的）。
读写锁
多个线程对同一个文件进行写操作时，会发生冲突所以需要加锁，但是对同一个文件进行读操作的时候，使用上面的方法会造成效率的降低，所以基于这种情况，产生了ReadWriteLock这个接口：
public interface ReadWriteLock { /** * Returns the lock used for reading. * * @return the lock used for reading. */ Lock readLock();//读的锁 /** * Returns the lock used for writing. * * @return the lock used for writing. */ Lock writeLock();//写的锁}
这个接口的实现类是ReentrantReadWriteLock，其源代码如下：
public class ReentrantReadWriteLock implements ReadWriteLock, Serializable { private static final long serialVersionUID = -6992448646407690164L; private final ReentrantReadWriteLock.ReadLock readerLock; private final ReentrantReadWriteLock.WriteLock writerLock; ... public ReentrantReadWriteLock.WriteLock writeLock() {//获取write lock return this.writerLock; } public ReentrantReadWriteLock.ReadLock readLock() {//获取read lock return this.readerLock; } ...}
使用方法和Lock一样，使用到write时调用writeLock()方法获取lock进行加锁，使用到read时调用readLock()方法进行加锁，需要注意的知识点如下：
线程A占用写锁，线程B在申请写、读的时候需要等待。
线程A占用读锁，线程B在申请写操作时，需要等待。
线程A占用读锁，线程B获取读操作时可以获取到。
总结
如果需要效率提升，则建议使用Lock，如果效率要求不高，则synchronized满足使用条件，业务逻辑写起来也简单，不需要手动释放锁。
PHP中文网，有大量免费的JAVA入门教程，欢迎大家学习！
以上就是什么是java线程同步的详细内容，更多请关注24课堂在线网其它相关文章！
