一、锁的原理
Java中每个对象都有一个内置锁，当程序运行到非静态的synchronized同步方法上时，自动获得与正在执行的代码类的当前实例(this实例)有关的锁。获得一个对象的锁也称为获取锁、锁定对象、在对象上锁定或在对象上同步。
当程序运行到synchronized同步方法或代码块时该对象锁才起作用。一个对象只有一个锁。所以一个线程获得该所，就没有其他线程获得，直到第一个线程释放(或返回)锁。这也意味着任何其他线程都不能进入该对象上的synchronized方法或代码块，直到该锁被释放。释放锁是指持锁线程退出synchronized同步方法或代码块。
2、注意事项
1) 只能同步方法，不能同步变量和类。
2) 每个对象只有一个锁，所以应该清楚在哪一个对象上同步。
3) 不必同步类的所有方法，类可以同时拥有同步和非同步方法。
4) 如果向拥有同步和非同步方法，则非同步方法可以被多个线程自由访问不受锁的限制。
5) 线程睡眠时，它所持的锁不会释放。
6) 线程可以获得多个锁。比如在一个对象的同步方法里面调用另一个对象的同步方法，则获得了两个对象的同步锁。
7) 同步损害并发性，应该尽可能缩小同步范围。同步不但可以同步整个方法，还可以同步方法中一部分代码块。
8) 使用同步代码块时，应该指出在哪个对象上同步，也就是说要获得哪个对象的锁，如
1 public int fix(int y){
2 synchronized(this){
3 x=x-y;
4 }
5 return x;
6 }
二、如果线程不能获得锁会怎么样
如果线程试图进入同步方法，而锁被其他线程占用，则该线程被阻塞。实际上，线程进入该对象的一种池中，必须在那里等待，直到其所被释放。
当考虑堵塞时，一定要注意哪个对象正在被用于锁定：
1、调用用一个对象中非静态同步方法的线程将被堵塞。如果是不同对象，则线程之间互不干扰。
2、调用同一个类中的静态同步方法的线程将被堵塞，它们都是锁定在相同的Cass对象上。
3、静态同步方法和非静态同步方法将永远不会彼此堵塞，因为静态方法锁定在Class对象上，非静态方法锁定在该类的对象上。
4、对于同步代码块，要看清楚什么对象已经用于锁定(synchronized后面括号的内容)。在同一个对象上进行同步的线程将被堵塞，在不同对象上的线程永远不会被堵塞。
三、锁对象
Java5中，提供了锁对象，利用锁对象可以实现资源的封锁，用来控制对竞争资源并发访问的控制，这些内容主要集中在java.util.concurrent.locks包下，主要有三个接口Condition、Lock、ReadEWriteLock。
1 Condition接口： 2 Condition将Object监视器方法(wait、notify和notifyAll)分解成截然不同的对象，以便 3 通过将这些对象与任意的Lock实现组合使用，为每个对象提供多个等待set(wait-set)。 4 Lock接口： 5 Lock实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操作。 6 ReadWriteLock接口： 7 ReadWriteLock维护了一对相关的锁定，一个用于只读操作，另一个用于写入操作。 8 下面是读写锁的必要步骤： 9 1)构造一个ReentrantReadWriteLock对象： 10 private ReentrantReadWriteLock rwl=new ReentrantReadWriteLock() 11 2)抽取读写锁： 12 private Lock readLock=rwl.readLock() 13 private Lock writeLock=rwl.writeLock() 14 3)对所有的获取方法加读锁： 15 public double getTotalBalance(){ 16 readLock.lock() 17 try{...} 18 finally{readLock.unlock()} 19 } 20 4)对所有的修改方法加写锁： 21 public double transfer(){ 22 writeLock.lock() 23 try{...} 24 finally{writeLock.unlock()} 25 }
具体看个例子：
LockTest.java
1 package Thread; 2 3 import java.util.concurrent.ExecutorService; 4 import java.util.concurrent.Executors; 5 import java.util.concurrent.locks.Lock; 6 import java.util.concurrent.locks.ReentrantLock; 7 8 /* 9 * Java线程：锁 10 */ 11 public class LockTest { 12 public static void main(String[] args){ 13 MyCount myCount=new MyCount("955464",10000);//创建并发访问的账户 14 Lock lock=new ReentrantLock();//创建一个所对象 15 ExecutorService pool=Executors.newCachedThreadPool();//创建一个线程池 16 User1 u1=new User1("张三",myCount,-4000,lock); 17 User1 u2=new User1("李四",myCount,6000,lock); 18 User1 u3=new User1("王二",myCount,-8000,lock); 19 User1 u4=new User1("麻子",myCount,800,lock); 20 //在线程池中执行各个用户的操作 21 pool.execute(u1); 22 pool.execute(u2); 23 pool.execute(u3); 24 pool.execute(u4); 25 pool.shutdown();//关闭线程池 26 } 27 } 28 class User1 implements Runnable{ 29 private String name;//用户名 30 private MyCount myCount;//所要操作的账户 31 private int iocash;//操作的余额，有正有负 32 private Lock myLock;//执行操作所需的锁对象 33 User1(String name,MyCount myCount,int iocash,Lock myLock){ 34 this.name=name; 35 this.myCount=myCount; 36 this.iocash=iocash; 37 this.myLock=myLock; 38 } 39 public void run(){ 40 myLock.lock();//获取锁 41 System.out.println(name+"正在操作"+myCount+"账户，金额为："+iocash+",当前金额为："+ 42 myCount.getCash());//执行现金任务 43 myCount.setCash(myCount.getCash()+iocash); 44 System.out.println(name+"操作"+myCount+"账户成功，金额为："+iocash+",当前金额为："+ 45 myCount.getCash()); 46 myLock.unlock();//释放锁，否则别的线程没有机会执行 47 } 48 } 49 class MyCount{ 50 private String oid;//账户 51 private int cash;//余额 52 MyCount(String oid,int cash){ 53 this.oid=oid; 54 this.cash=cash; 55 } 56 public String getOid(){ 57 return oid; 58 } 59 public void setOid(String oid){ 60 this.oid=oid; 61 } 62 public int getCash(){ 63 return cash; 64 } 65 public void setCash(int cash){ 66 this.cash=cash; 67 } 68 public String toString(){ 69 return "MyCount{oid="+oid+",cash="+cash+"}"; 70 } 71 }
结果为：
1 张三正在操作MyCount{oid=955464,cash=10000}账户，金额为：-4000,当前金额为：10000 2 张三操作MyCount{oid=955464,cash=6000}账户成功，金额为：-4000,当前金额为：6000 3 李四正在操作MyCount{oid=955464,cash=6000}账户，金额为：6000,当前金额为：6000 4 李四操作MyCount{oid=955464,cash=12000}账户成功，金额为：6000,当前金额为：12000 5 王二正在操作MyCount{oid=955464,cash=12000}账户，金额为：-8000,当前金额为：12000 6 王二操作MyCount{oid=955464,cash=4000}账户成功，金额为：-8000,当前金额为：4000 7 麻子正在操作MyCount{oid=955464,cash=4000}账户，金额为：800,当前金额为：4000 8 麻子操作MyCount{oid=955464,cash=4800}账户成功，金额为：800,当前金额为：4800
上述例子是普通的锁，不区分读写，在这里，为了提高性能，读的地方用读锁，写的地方用写锁，提高了执行效率。平时的时候尽量写读写锁，不用普通锁。
LockTest.java
1 package Thread; 2 3 import java.util.concurrent.ExecutorService; 4 import java.util.concurrent.Executors; 5 import java.util.concurrent.locks.Lock; 6 import java.util.concurrent.locks.ReadWriteLock; 7 import java.util.concurrent.locks.ReentrantLock; 8 import java.util.concurrent.locks.ReentrantReadWriteLock; 9 10 /* 11 * Java线程：锁 12 */ 13 public class LockTest { 14 public static void main(String[] args){ 15 MyCount myCount=new MyCount("955464",10000);//创建并发访问的账户 16 ReadWriteLock lock=new ReentrantReadWriteLock(false);//创建一个所对象 17 ExecutorService pool=Executors.newCachedThreadPool();//创建一个线程池 18 User1 u1=new User1("张三",myCount,-4000,lock,false); 19 User1 u2=new User1("李四",myCount,6000,lock,false); 20 User1 u3=new User1("王二",myCount,-8000,lock,false); 21 User1 u4=new User1("麻子",myCount,800,lock,false); 22 User1 u5=new User1("麻子它姐",myCount,0,lock,true); 23 //在线程池中执行各个用户的操作 24 pool.execute(u1); 25 pool.execute(u2); 26 pool.execute(u3); 27 pool.execute(u4); 28 pool.execute(u5); 29 pool.shutdown();//关闭线程池 30 } 31 } 32 class User1 implements Runnable{ 33 private String name;//用户名 34 private MyCount myCount;//所要操作的账户 35 private int iocash;//操作的余额，有正有负 36 private ReadWriteLock myLock;//执行操作所需的锁对象 37 private boolean ischeck;//是否查询 38 User1(String name,MyCount myCount,int iocash,ReadWriteLock myLock,boolean ischeck){ 39 this.name=name; 40 this.myCount=myCount; 41 this.iocash=iocash; 42 this.myLock=myLock; 43 this.ischeck=ischeck; 44 } 45 public void run(){ 46 if(ischeck){ 47 myLock.readLock().lock();//获取锁 48 System.out.println("读："+name+"正在查询"+myCount+",当前金额为："+ 49 myCount.getCash());//执行现金任务 50 myLock.readLock().unlock(); 51 }else{ 52 myLock.writeLock().lock(); 53 System.out.println("写："+name+"正在操作"+myCount+"账户，金额为："+iocash+",当前金额为："+ 54 myCount.getCash());//执行现金任务 55 myCount.setCash(myCount.getCash()+iocash); 56 System.out.println("写："+name+"操作"+myCount+"账户成功，金额为："+iocash+",当前金额为："+ 57 myCount.getCash()); 58 myLock.writeLock().unlock();//释放锁，否则别的线程没有机会执行 59 } 60 } 61 } 62 class MyCount{ 63 private String oid;//账户 64 private int cash;//余额 65 MyCount(String oid,int cash){ 66 this.oid=oid; 67 this.cash=cash; 68 } 69 public String getOid(){ 70 return oid; 71 } 72 public void setOid(String oid){ 73 this.oid=oid; 74 } 75 public int getCash(){ 76 return cash; 77 } 78 public void setCash(int cash){ 79 this.cash=cash; 80 } 81 public String toString(){ 82 return "MyCount{oid="+oid+",cash="+cash+"}"; 83 } 84 }
结果为：
1 写：张三正在操作MyCount{oid=955464,cash=10000}账户，金额为：-4000,当前金额为：10000 2 写：张三操作MyCount{oid=955464,cash=6000}账户成功，金额为：-4000,当前金额为：6000 3 写：王二正在操作MyCount{oid=955464,cash=6000}账户，金额为：-8000,当前金额为：6000 4 写：王二操作MyCount{oid=955464,cash=-2000}账户成功，金额为：-8000,当前金额为：-2000 5 写：李四正在操作MyCount{oid=955464,cash=-2000}账户，金额为：6000,当前金额为：-2000 6 写：李四操作MyCount{oid=955464,cash=4000}账户成功，金额为：6000,当前金额为：4000 7 读：麻子它姐正在查询MyCount{oid=955464,cash=4000},当前金额为：4000 8 写：麻子正在操作MyCount{oid=955464,cash=4000}账户，金额为：800,当前金额为：4000 9 写：麻子操作MyCount{oid=955464,cash=4800}账户成功，金额为：800,当前金额为：4800
四、死锁
死锁发生的可能性很小，即使看似死锁的代码，运行时也不一定产生死锁，发生死锁的原因是：当两个线程被堵塞， 每个线程在等待另一个线程时发生死锁，一般是两个对象的锁相互等待造成的。具体例子：
DeathLockTest.java
1 package Thread; 2 3 public class DeathLockTest { 4 public static void main(String[] args){ 5 DeadlockRisk dead=new DeadlockRisk(); 6 MyThread1 t1=new MyThread1(dead,1,2); 7 MyThread1 t2=new MyThread1(dead,3,4); 8 MyThread1 t3=new MyThread1(dead,5,6); 9 MyThread1 t4=new MyThread1(dead,7,8); 10 t1.start(); 11 t2.start(); 12 t3.start(); 13 t4.start(); 14 } 15 } 16 class MyThread1 extends Thread{ 17 private DeadlockRisk dead; 18 private int a,b; 19 MyThread1(DeadlockRisk dead,int a,int b){ 20 this.dead=dead; 21 this.a=a; 22 this.b=b; 23 } 24 public void run(){ 25 dead.read(); 26 dead.write(a,b); 27 } 28 } 29 class DeadlockRisk{ 30 private static class Resource{ 31 public int value; 32 } 33 private Resource resourceA=new Resource(); 34 private Resource resourceB=new Resource(); 35 public int read(){ 36 synchronized (resourceA){ 37 System.out.println("read():"+Thread.currentThread().getName()+"获取了resourceA的锁！"); 38 synchronized (resourceB){ 39 System.out.println("read():"+Thread.currentThread().getName()+"获取了resourceB的锁！"); 40 return resourceB.value+resourceA.value; 41 } 42 } 43 } 44 public void write(int a,int b){ 45 synchronized (resourceB){ 46 System.out.println("write():"+Thread.currentThread().getName()+"获取了resourceA的锁！"); 47 synchronized (resourceA){ 48 System.out.println("write():"+Thread.currentThread().getName()+"获取了resourceB的锁！"); 49 resourceB.value=b; 50 resourceA.value=a; 51 } 52 } 53 } 54 }
结果为：
1 read():Thread-0获取了resourceA的锁！ 2 read():Thread-0获取了resourceB的锁！ 3 write():Thread-0获取了resourceA的锁！ 4 read():Thread-3获取了resourceA的锁！
这时，产生了死锁，程序不能继续运行了，但是如果修改一下，就能避免死锁。
DeathLockTest.java
1 package Thread; 2 3 public class DeathLockTest { 4 public static void main(String[] args){ 5 DeadlockRisk dead=new DeadlockRisk(); 6 MyThread1 t1=new MyThread1(dead,1,2); 7 MyThread1 t2=new MyThread1(dead,3,4); 8 MyThread1 t3=new MyThread1(dead,5,6); 9 MyThread1 t4=new MyThread1(dead,7,8); 10 t1.start(); 11 t2.start(); 12 t3.start(); 13 t4.start(); 14 } 15 } 16 class MyThread1 extends Thread{ 17 private DeadlockRisk dead; 18 private int a,b; 19 MyThread1(DeadlockRisk dead,int a,int b){ 20 this.dead=dead; 21 this.a=a; 22 this.b=b; 23 } 24 public void run(){ 25 dead.read(); 26 dead.write(a,b); 27 } 28 } 29 class DeadlockRisk{ 30 private static class Resource{ 31 public int value; 32 } 33 private Resource resourceA=new Resource(); 34 private Resource resourceB=new Resource(); 35 public int read(){ 36 synchronized (resourceA){ 37 System.out.println("read():"+Thread.currentThread().getName()+"获取了resourceA的锁！"); 38 synchronized (resourceB){ 39 System.out.println("read():"+Thread.currentThread().getName()+"获取了resourceB的锁！"); 40 return resourceB.value+resourceA.value; 41 } 42 } 43 } 44 public void write(int a,int b){ 45 synchronized (resourceA){ 46 System.out.println("write():"+Thread.currentThread().getName()+"获取了resourceA的锁！"); 47 synchronized (resourceB){ 48 System.out.println("write():"+Thread.currentThread().getName()+"获取了resourceB的锁！"); 49 resourceB.value=b; 50 resourceA.value=a; 51 } 52 } 53 } 54 }
结果为：
1 read():Thread-0获取了resourceA的锁！ 2 read():Thread-0获取了resourceB的锁！ 3 read():Thread-3获取了resourceA的锁！ 4 read():Thread-3获取了resourceB的锁！ 5 write():Thread-3获取了resourceA的锁！ 6 write():Thread-3获取了resourceB的锁！ 7 read():Thread-2获取了resourceA的锁！ 8 read():Thread-2获取了resourceB的锁！ 9 write():Thread-2获取了resourceA的锁！ 10 write():Thread-2获取了resourceB的锁！ 11 read():Thread-1获取了resourceA的锁！ 12 read():Thread-1获取了resourceB的锁！ 13 write():Thread-1获取了resourceA的锁！ 14 write():Thread-1获取了resourceB的锁！ 15 write():Thread-0获取了resourceA的锁！ 16 write():Thread-0获取了resourceB的锁！
当神已无能为力，那便是魔渡众生
![[Java]线程生命周期与线程通信](https://ucc.alicdn.com/3mfxe2r26qbaq/developer-article1631772/20241030/ced52a6851b84bbeb3f6ca0b217bb4c4.png?x-oss-process=image/resize,h_160,m_lfit)