[关闭]
@huangyichun 2017-08-30T08:09:10.000000Z 字数 3979 阅读 898

Java多线程方法锁

多线程

本文主要介绍在多线程中对于普通方法和静态方法加锁调用产生的情况。
结论:

(1) 非静态方法锁默认为this也就是作用在对象上，静态方法的锁对应 Class实例(类加载会生成一个Class实例)
(2) 某一个时刻内，只有一个线程可以持有锁，无论几个方法

下面主要是验证这两个结论:

1.两个普通同步方法，开启两个线程调用

  1.     class Number{
  2.         public synchronized void getOne()  {
  3.             System.out.println("one");
  4.         }
  6.         public synchronized  void getTwo(){
  7.             System.out.println("two");
  8.         }
  9.     }
  1.       public static void main(String[] args) {
  2.             Number number = new Number();
  4.             new Thread(new Runnable() {
  5.                 @Override
  6.                 public void run() {
  7.                     number.getOne();
  8.                 }
  9.             }).start();
  11.             new Thread(new Runnable() {
  12.                 @Override
  13.                 public void run() {
  14.                     number.getTwo();
  15.                 }
  16.             }).start();
  17.         }

运行结果为: 

one
two

2.在上面的基础上修改getOne()方法添加Thread.sleep()

  1.      public synchronized void getOne()  {
  2.             try {
  3.                 Thread.sleep(3000);
  4.             } catch (InterruptedException e) {
  5.                 e.printStackTrace();
  6.             }
  7.             System.out.println("one");
  8.         }

运行结果为:

 one
 two

说明了两个方法调用的是同一个锁，锁先被线程一调用了，导致线程二处于等待状态，当线程一执行完后，线程二才能继续执行

3. 新增getThree()方法，同时开启三个线程调用这三个方法

  1.     public class TestThread8Monitor {
  2.         public static void main(String[] args) {
  3.             Number number = new Number();
  5.             new Thread(new Runnable() {
  6.                 @Override
  7.                 public void run() {
  8.                     number.getOne();
  9.                 }
  10.             }).start();
  12.             new Thread(new Runnable() {
  13.                 @Override
  14.                 public void run() {
  15.                     number.getTwo();
  16.                 }
  17.             }).start();
  19.             new Thread(new Runnable() {
  20.                 @Override
  21.                 public void run() {
  22.                     number.getThree();
  23.                 }
  24.             }).start();
  25.         }
  26.     }
  28.     class Number{
  29.         public synchronized void getOne()  {
  30.             try {
  31.                 Thread.sleep(3000);
  32.             } catch (InterruptedException e) {
  33.                 e.printStackTrace();
  34.             }
  35.             System.out.println("one");
  36.         }
  38.         public  synchronized  void getTwo(){
  39.             System.out.println("two");
  40.         }
  42.         public void getThree(){//普通未加锁方法
  43.             System.out.println("three");
  44.         }
  45.     }

运行结果:

three
one
two

说明:普通方法不受线程锁的影响，线程三直接执行，无须等待前面的线程释放锁

4.创建number的两个实例分别调用getOne()和getTwo()方法

  1.     public class TestThread8Monitor {
  3.         public static void main(String[] args) {
  4.             Number number = new Number();
  5.             Number number2 = new Number();
  6.             new Thread(new Runnable() {
  7.                 @Override
  8.                 public void run() {
  9.                     number.getOne();
  10.                 }
  11.             }).start();
  13.             new Thread(new Runnable() {
  14.                 @Override
  15.                 public void run() {
  16.                     number2.getTwo();
  17.                 }
  18.             }).start();
  19.         }
  20.     }
  22.     class Number{
  23.         public synchronized void getOne()  {
  24.             try {
  25.                 Thread.sleep(3000);//等待3秒
  26.             } catch (InterruptedException e) {
  27.                 e.printStackTrace();
  28.             }
  29.             System.out.println("one");
  30.         }
  32.         public  synchronized  void getTwo(){
  33.             System.out.println("two");
  34.         }
  35.     }

运行结果: two one
说明：调用加锁的普通方法，上锁的是this，也就是该对象，因此两个线程分别调用两个不同的对象，两者之间不存在互斥等待问题。

5.将getOne()改为静态方法，两个线程同时调用一个对象的不同方法

  1.     public class TestThread8Monitor {
  3.         public static void main(String[] args) {
  4.             Number number = new Number();
  5.             new Thread(new Runnable() {
  6.                 @Override
  7.                 public void run() {
  8.                     number.getOne();
  9.                 }
  10.             }).start();
  12.             new Thread(new Runnable() {
  13.                 @Override
  14.                 public void run() {
  15.                     number.getTwo();
  16.                 }
  17.             }).start();
  18.         }
  19.     }
  21.     class Number{
  22.         public static synchronized void getOne()  {
  23.             try {
  24.                 Thread.sleep(3000);
  25.             } catch (InterruptedException e) {
  26.                 e.printStackTrace();
  27.             }
  28.             System.out.println("one");
  29.         }
  31.         public  synchronized  void getTwo(){
  32.             System.out.println("two");
  33.         }
  34.     }

运行结果: two one

说明: 静态方法锁和普通方法锁的目标不同。

6.同时将两个方法设置为静态方法，两个线程调用同一对象的两个方法

  1.    public class TestThread8Monitor {
  2.     public static void main(String[] args) {
  3.         Number number = new Number();
  4.         Number number2 = new Number();
  5.         new Thread(new Runnable() {
  6.             @Override
  7.             public void run() {
  8.                 number.getOne();
  9.             }
  10.         }).start();
  12.         new Thread(new Runnable() {
  13.             @Override
  14.             public void run() {
  15.                 number2.getTwo();
  16.             }
  17.         }).start();
  18.     }
  19. }
  21. class Number{
  22.     public static synchronized void getOne()  {
  23.         try {
  24.             Thread.sleep(3000);
  25.         } catch (InterruptedException e) {
  26.             e.printStackTrace();
  27.         }
  28.         System.out.println("one");
  29.     }
  31.     public static synchronized  void getTwo(){
  32.         System.out.println("two");
  33.     }
  34. }

运行结果: one two
说明:静态方法加锁是在类上的，也就是类的Class实例。因此两个线程调用两个对象的不同方法，结果却需要互斥调用

可重入锁ReentrantLock

  1.     //非公平锁
  2.      final boolean nonfairTryAcquire(int acquires) {
  3.                 final Thread current = Thread.currentThread();
  4.                 int c = getState();
  5.                 if (c == 0) {
  6.                     if (compareAndSetState(0, acquires)) {
  7.                         setExclusiveOwnerThread(current);
  8.                         return true;
  9.                     }
  10.                 }
  11.                 else if (current == getExclusiveOwnerThread()) {
  12.                     int nextc = c + acquires;
  13.                     if (nextc < 0) // overflow
  14.                         throw new Error("Maximum lock count exceeded");
  15.                     setState(nextc);
  16.                     return true;
  17.                 }
  18.                 return false;
  19.             }
  1.     //公平锁
  2.      protected final boolean tryAcquire(int acquires) {
  3.                 final Thread current = Thread.currentThread();
  4.                 int c = getState();
  5.                 if (c == 0) {
  6.                     if (!hasQueuedPredecessors() &&
  7.                         compareAndSetState(0, acquires)) {
  8.                         setExclusiveOwnerThread(current);
  9.                         return true;
  10.                     }
  11.                 }
  12.                 else if (current == getExclusiveOwnerThread()) {
  13.                     int nextc = c + acquires;
  14.                     if (nextc < 0)
  15.                         throw new Error("Maximum lock count exceeded");
  16.                     setState(nextc);
  17.                     return true;
  18.                 }
  19.                 return false;
  20.             }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注