你的位置:首页 > Java教程

[Java教程]Java线程:锁


一、锁的原理

  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 }

View Code

  结果为:

1 张三正在操作MyCount{oid=955464,cash=10000}账户,金额为:-4000,当前金额为:100002 张三操作MyCount{oid=955464,cash=6000}账户成功,金额为:-4000,当前金额为:60003 李四正在操作MyCount{oid=955464,cash=6000}账户,金额为:6000,当前金额为:60004 李四操作MyCount{oid=955464,cash=12000}账户成功,金额为:6000,当前金额为:120005 王二正在操作MyCount{oid=955464,cash=12000}账户,金额为:-8000,当前金额为:120006 王二操作MyCount{oid=955464,cash=4000}账户成功,金额为:-8000,当前金额为:40007 麻子正在操作MyCount{oid=955464,cash=4000}账户,金额为:800,当前金额为:40008 麻子操作MyCount{oid=955464,cash=4800}账户成功,金额为:800,当前金额为:4800

View Code

   上述例子是普通的锁,不区分读写,在这里,为了提高性能,读的地方用读锁,写的地方用写锁,提高了执行效率。平时的时候尽量写读写锁,不用普通锁。

  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 }

View Code

  结果为:

1 写:张三正在操作MyCount{oid=955464,cash=10000}账户,金额为:-4000,当前金额为:100002 写:张三操作MyCount{oid=955464,cash=6000}账户成功,金额为:-4000,当前金额为:60003 写:王二正在操作MyCount{oid=955464,cash=6000}账户,金额为:-8000,当前金额为:60004 写:王二操作MyCount{oid=955464,cash=-2000}账户成功,金额为:-8000,当前金额为:-20005 写:李四正在操作MyCount{oid=955464,cash=-2000}账户,金额为:6000,当前金额为:-20006 写:李四操作MyCount{oid=955464,cash=4000}账户成功,金额为:6000,当前金额为:40007 读:麻子它姐正在查询MyCount{oid=955464,cash=4000},当前金额为:40008 写:麻子正在操作MyCount{oid=955464,cash=4000}账户,金额为:800,当前金额为:40009 写:麻子操作MyCount{oid=955464,cash=4800}账户成功,金额为:800,当前金额为:4800

View Code

四、死锁

  死锁发生的可能性很小,即使看似死锁的代码,运行时也不一定产生死锁,发生死锁的原因是:当两个线程被堵塞, 每个线程在等待另一个线程时发生死锁,一般是两个对象的锁相互等待造成的。具体例子:

  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 }

View Code

  结果为:

1 read():Thread-0获取了resourceA的锁!2 read():Thread-0获取了resourceB的锁!3 write():Thread-0获取了resourceA的锁!4 read():Thread-3获取了resourceA的锁!

View Code

  这时,产生了死锁,程序不能继续运行了,但是如果修改一下,就能避免死锁。

  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 }

View Code

  结果为:

 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的锁!

View Code