手册   游戏   WEB   字典   单词   在线工具  

Java 并发编程基础 -- 同步

一, synchronized 关键字

1)synchronized 锁什么? 锁对象. 可能锁对象包括: this, 临界资源对象, Class 类对象. 如同下面例子所示;

  1. package cn.test.juc;
  2.  public class TestSynchronized {
  3.      private int count = 0;
  4.      private Object object = new Object();
  5.      public void testSyn1() {
  6.          // 锁对象(这里面是锁临界资源)
  7.          synchronized (object) {
  8.              System.out.println(Thread.currentThread().getName()
  9.                  +"count =" + count++);
  10.          }
  11.      }
  12.      public void testSyn2() {
  13.          // 锁当前对象
  14.          synchronized (this) {
  15.              System.out.println(Thread.currentThread().getName()
  16.                      +"count =" + count++);
  17.          }
  18.      }
  19.      // 锁当前对象
  20.      public synchronized void testSyn3() {
  21.          System.out.println(Thread.currentThread().getName()
  22.                  +"count =" + count++);
  23.      }
  24.  }

2)如果在加锁的时候对当前对象的访问限定要求比较低的时候, 建议锁某一段代码或者某一个对象; 如果访问限定要求比较高的话, 建议锁当前对象. 简单而言就可以说是减小锁的范围. 对于锁当前对象

或者

都是重量级锁, 什么意思呢,"就是任意多个线程, 多个资源不会被多个线程访问所影响的"

3)再看下面的例子, 锁当前类的类对象的两种方式:

  1. public class TestSynchronized02 {
  2.      private static int staticCount = 0;
  3.      // 静态同步方法, 锁的是当前类型的类对象(即 TestSynchronized02.class)
  4.      public static synchronized void testSyn1() {
  5.          System.out.println(Thread.currentThread().getName()
  6.                  +"staticCount =" + staticCount++);
  7.      }
  8.      // 下面的这种方式也是锁当前类型的类对象
  9.      public static void testSyn2() {
  10.          synchronized (TestSynchronized02.class) {
  11.              System.out.println(Thread.currentThread().getName()
  12.                      +"staticCount =" + staticCount++);
  13.          }
  14.      }
  15.  }

4)看一下下面一段小程序的运行结果

  1. public class TestSynchronized03 implements Runnable{
  2.      private int count  = 0;
  3.      @Override
  4.      public /*synchronized */ void run() {
  5.          System.out.println(Thread.currentThread().getName()
  6.                  +"count =" + count++);
  7.      }
  8.      public static void main(String[] args) {
  9.          TestSynchronized03 testSynchronized03 = new TestSynchronized03();
  10.          for (int i = 0; i <10 ; i++) {
  11.              new Thread(testSynchronized03, "Thread ---" + i).start();
  12.          }
  13.      }
  14.  }

我们发下下面的结果少加了一个 1, 这就是原子性的问题. 在 synchronized 关键字没有使用的时候, 对于变量 count 而言 (由多个线程访问), 是不能保证原子性(某一段代码从开始运行到结束不能分步执行) 的, 上面的代码没有使用同步, 那么很显然多线程对变量进行加操作就可能会在同一时刻只进行 1 次加操作

5)关于同步方法和非同步方法: 同步方法只影响 锁定同一个锁对象的同步方法, 不影响非同步方法被其他线程调用, 也不影响其他所资源的同步方法(简单理解就是锁的不是同一个资源, 就不会影响);

  1. package cn.test.juc;
  2.  public class TestSynchronized04 {
  3.      private Object o = new Object();
  4.      // 同步方法
  5.      public synchronized void m1() {
  6.          System.out.println("public synchronized void m1() start.");
  7.          try {
  8.              Thread.sleep(3000);
  9.          } catch (InterruptedException e) {
  10.              e.printStackTrace();
  11.          }
  12.          System.out.println("public synchronized void m1() end.");
  13.      }
  14.      public void m3() {
  15.          synchronized (o) {
  16.              System.out.println("public void m3() start.");
  17.              try {
  18.                  Thread.sleep(1500);
  19.              } catch (InterruptedException e) {
  20.                  e.printStackTrace();
  21.              }
  22.              System.out.println("public void m3() end.");
  23.          }
  24.      }
  25.      // 非同步方法
  26.      public void m2() {
  27.          System.out.println("public void m2() start.");
  28.          try {
  29.              Thread.sleep(1500);
  30.          } catch (InterruptedException e) {
  31.              e.printStackTrace();
  32.          }
  33.          System.out.println("public void m2() end.");
  34.      }
  35.      public static class MyThread implements Runnable{
  36.          int i;
  37.          TestSynchronized04 testSynchronized04;
  38.          public MyThread(int i, TestSynchronized04 testSynchronized04) {
  39.              this.i = i;
  40.              this.testSynchronized04 = testSynchronized04;
  41.          }
  42.          @Override
  43.          public void run() {
  44.              if(i == 0) {
  45.                  testSynchronized04.m1();
  46.              } else if(i == 1) {
  47.                  testSynchronized04.m3();
  48.              } else {
  49.                  testSynchronized04.m2();
  50.              }
  51.          }
  52.      }
  53.      public static void main(String[] args) {
  54.          TestSynchronized04 testSynchronized04 = new TestSynchronized04();
  55.          new Thread(new TestSynchronized04.MyThread(0, testSynchronized04)).start();
  56.          new Thread(new TestSynchronized04.MyThread(1, testSynchronized04)).start();
  57.          new Thread(new TestSynchronized04.MyThread(2, testSynchronized04)).start();
  58.      }
  59.  }

下面是运行的结果

6)脏读问题

  1. package cn.test.juc;
  2.  import java.util.concurrent.TimeUnit;
  3.  public class TestSynchronized05 {
  4.      private double d = 0.0;
  5.      // 相当与是 set 方法
  6.      public synchronized void m1(double d) {
  7.          try {
  8.              TimeUnit.SECONDS.sleep(2);
  9.          } catch (InterruptedException e) {
  10.              e.printStackTrace();
  11.          }
  12.          this.d = d;
  13.      }
  14.      // 相当于是 get 方法
  15.      public double m2() {
  16.          return this.d;
  17.      }
  18.      public static void main(String[] args) {
  19.          final TestSynchronized05 testSynchronized05 = new TestSynchronized05();
  20.          new Thread(new Runnable() {
  21.              @Override
  22.              public void run() {
  23.                  testSynchronized05.m1(100);
  24.              }
  25.          }).start();
  26.          System.out.println(testSynchronized05.m2());
  27.          try {
  28.              TimeUnit.SECONDS.sleep(3);
  29.          } catch (InterruptedException e) {
  30.              e.printStackTrace();
  31.          }
  32.          System.out.println(testSynchronized05.m2());
  33.      }
  34.  }

上面代码的输出是 0.0 100.00, 而不是期望的 100.00 100.00, 出现这种情况 (脏读) 的原因是什么的? 就是 m1 方法的这段代码引起的

这段代码表示睡眠 2 秒之后再进行 set 操作, 使用这一段代码的原因就是模拟实际当中的复杂处理操作, 可能会比较耗时, 但是这时候还没执行完毕没有将正确的结果写会, 别的线程就去访问临界资源的话, 就会出现脏读的情况.

7)锁的可重入问题: 同一个线程, 多次调用同步代码, 锁定同一个对象, 可重入

看看下面的代码实例: main 调用 m1 方法, m1 方法中调用 m2 方法, 两个方法锁定的都是 this 对象, 就会是上面说到的这种情况

  1. package cn.test.juc;
  2.  import java.util.concurrent.TimeUnit;
  3.  public class TestSynchronized06 {
  4.      synchronized void m1() { // 锁 this
  5.          System.out.println("m1 start()");
  6.          try {
  7.              TimeUnit.SECONDS.sleep(2);
  8.          } catch (InterruptedException e) {
  9.              e.printStackTrace();
  10.          }
  11.          m2();
  12.          System.out.println("m1 end()");
  13.      }
  14.      synchronized void m2() { // 锁 this
  15.          System.out.println("m2 start()");
  16.          try {
  17.              TimeUnit.SECONDS.sleep(1);
  18.          } catch (InterruptedException e) {
  19.              e.printStackTrace();
  20.          }
  21.          System.out.println("m2 end()");
  22.      }
  23.      public static void main(String[] args) {
  24.          new TestSynchronized06().m1();
  25.      }
  26.  }

8)关于同步的继承问题: 同一个线程中, 子类同步方法覆盖父类的同步方法, 可以指定调用父类的同步方法(相当于锁的重入);

  1. package cn.test.juc;
  2.  import java.util.concurrent.TimeUnit;
  3.  public class TestSynchronized07 {
  4.      synchronized void m() {
  5.          System.out.println("Super Class m start");
  6.          try {
  7.              TimeUnit.SECONDS.sleep(1);
  8.          } catch (InterruptedException e) {
  9.              e.printStackTrace();
  10.          }
  11.          System.out.println("Super Class m end");
  12.      }
  13.      public static void main(String[] args) {
  14.          new ExtendTest07().m();
  15.      }
  16.  }
  17.  class ExtendTest07 extends TestSynchronized07 {
  18.      synchronized void m() {
  19.          System.out.println("Sub Class m start");
  20.          super.m();
  21.          System.out.println("Sub Class m end");
  22.      }
  23.  }

9)锁与异常: 当同步方法出现异常的时候会自动释放锁, 不会影响其他线程的执行

  1. package cn.test.juc;
  2.  import java.util.concurrent.TimeUnit;
  3.  public class TestSynchronized08 {
  4.      int i = 0;
  5.      synchronized void m(){
  6.          System.out.println(Thread.currentThread().getName() + "- start");
  7.          while(true){
  8.              i++;
  9.              System.out.println(Thread.currentThread().getName() + "-" + i);
  10.              try {
  11.                  TimeUnit.SECONDS.sleep(1);
  12.              } catch (InterruptedException e) {
  13.                  // TODO Auto-generated catch block
  14.                  e.printStackTrace();
  15.              }
  16.              if(i == 5){
  17.                  i = 1/0;
  18.              }
  19.          }
  20.      }
  21.      public static void main(String[] args) {
  22.          final TestSynchronized08 t = new TestSynchronized08();
  23.          new Thread(new Runnable() {
  24.              @Override
  25.              public void run() {
  26.                  t.m();
  27.              }
  28.          }, "t1").start();
  29.          new Thread(new Runnable() {
  30.              @Override
  31.              public void run() {
  32.                  t.m();
  33.              }
  34.          }, "t2").start();
  35.      }
  36.  }

下面是输出的结果:

10)synchronized 锁的是对象, 而不是引用: 同步代码一旦加锁之后会有一个临时锁引用执行锁对象, 和真实的引用无直接关联, 在锁释放之前, 修改锁对象引用不会影响同步代码块的执行

  1. package cn.test.syn;
  2.  import java.util.concurrent.TimeUnit;
  3.  public class TestSynchronized09 {
  4.      Object o = new Object();
  5.      int i = 0;
  6.      int a(){
  7.          try{
  8.              /*
  9.               * return i ->
  10.               * int _returnValue = i; // 0;
  11.               * return _returnValue;
  12.               */
  13.              return i;
  14.          }finally{
  15.              i = 10;
  16.          }
  17.      }
  18.      void m(){
  19.          System.out.println(Thread.currentThread().getName() + "start");
  20.          synchronized (o) {
  21.              while(true){
  22.                  try {
  23.                      TimeUnit.SECONDS.sleep(1);
  24.                  } catch (InterruptedException e) {
  25.                      e.printStackTrace();
  26.                  }
  27.                  System.out.println(Thread.currentThread().getName() + "-" + o);
  28.              }
  29.          }
  30.      }
  31.      public static void main(String[] args) {
  32.          final TestSynchronized09 t = new TestSynchronized09();
  33.          new Thread(new Runnable() {
  34.              @Override
  35.              public void run() {
  36.                  t.m();
  37.              }
  38.          }, "thread1").start();
  39.          try {
  40.              TimeUnit.SECONDS.sleep(3);
  41.          } catch (InterruptedException e) {
  42.              e.printStackTrace();
  43.          }
  44.          Thread thread2 = new Thread(new Runnable() {
  45.              @Override
  46.              public void run() {
  47.                  t.m();
  48.              }
  49.          }, "thread2");
  50.          t.o = new Object();
  51.          thread2.start();
  52.          System.out.println(t.i);
  53.          System.out.println(t.a());
  54.          System.out.println(t.i);
  55.      }
  56.  }

11)synchronized 中的常量问题: 在定义同步代码块的时候, 不要使用常量对象作为锁对象

  1. package cn.test.syn;
  2.  import java.util.concurrent.TimeUnit;
  3.  public class TestSynchronized09 {
  4.      Object o = new Object();
  5.      int i = 0;
  6.      int a(){
  7.          try{
  8.              /*
  9.               * return i ->
  10.               * int _returnValue = i; // 0;
  11.               * return _returnValue;
  12.               */
  13.              return i;
  14.          }finally{
  15.              i = 10;
  16.          }
  17.      }
  18.      void m(){
  19.          System.out.println(Thread.currentThread().getName() + "start");
  20.          synchronized (o) {
  21.              while(true){
  22.                  try {
  23.                      TimeUnit.SECONDS.sleep(1);
  24.                  } catch (InterruptedException e) {
  25.                      e.printStackTrace();
  26.                  }
  27.                  System.out.println(Thread.currentThread().getName() + "-" + o);
  28.              }
  29.          }
  30.      }
  31.      public static void main(String[] args) {
  32.          final TestSynchronized09 t = new TestSynchronized09();
  33.          new Thread(new Runnable() {
  34.              @Override
  35.              public void run() {
  36.                  t.m();
  37.              }
  38.          }, "thread1").start();
  39.          try {
  40.              TimeUnit.SECONDS.sleep(3);
  41.          } catch (InterruptedException e) {
  42.              e.printStackTrace();
  43.          }
  44.          Thread thread2 = new Thread(new Runnable() {
  45.              @Override
  46.              public void run() {
  47.                  t.m();
  48.              }
  49.          }, "thread2");
  50.          t.o = new Object();
  51.          thread2.start();
  52.          System.out.println(t.i);
  53.          System.out.println(t.a());
  54.          System.out.println(t.i);
  55.      }
  56.  }

二, Volatile 关键字

1, 下面的代码在没有使用 volatile 之前, 是不会从循环中跳出的 (main 线程和新创建的线程互相之间是不可见的, 所以新创建的线程在使用 m 方法的时候并不知道 main 线程已经改变了 b 的值, 所以不会跳出循环), 那么使用 volatile 会怎样呢(简单说是可见性) 但是啥是可见性: 就是告知 OS 在管理 CPU 计算过程中要检查内存中的数据的有效性, 保证使用的数据都是有效的.

  1. package cn.test.Volatile;
  2.  import java.util.concurrent.TimeUnit;
  3.  public class TestVolatile01 {
  4.      /*volatile*/ boolean b = true;
  5.      void m(){
  6.          System.out.println("start");
  7.          while(b){}
  8.          System.out.println("end");
  9.      }
  10.      public static void main(String[] args) {
  11.          final TestVolatile01 t = new TestVolatile01();
  12.          new Thread(new Runnable() {
  13.              @Override
  14.              public void run() {
  15.                  t.m();
  16.              }
  17.          }).start();
  18.          try {
  19.              TimeUnit.SECONDS.sleep(1);
  20.          } catch (InterruptedException e) {
  21.              e.printStackTrace();
  22.          }
  23.          t.b = false;
  24.      }
  25.  }

2,volatile 只能保证可见性, 不能保证原子性, volatile 不是加锁问题, 只是保证内存数据可见; 参照下面的例子, 运行的结果不是期望的 100000, 而是

当然, 也不一定每次都是这个值.

  1. package cn.test.Volatile;
  2.  import java.util.ArrayList;
  3.  import java.util.List;
  4.  public class TestVolatile02 {
  5.      volatile int count = 0;
  6.      /*synchronized*/ void m(){
  7.          for(int i = 0; i <10000; i++){
  8.              count++;
  9.          }
  10.      }
  11.      public static void main(String[] args) {
  12.          final TestVolatile02 t = new TestVolatile02();
  13.          List<Thread> threads = new ArrayList<>();
  14.          for(int i = 0; i <10; i++){
  15.              threads.add(new Thread(new Runnable() {
  16.                  @Override
  17.                  public void run() {
  18.                      t.m();
  19.                  }
  20.              }));
  21.          }
  22.          for(Thread thread : threads){
  23.              thread.start();
  24.          }
  25.          for(Thread thread : threads){
  26.              try {
  27.                  thread.join();
  28.              } catch (InterruptedException e) {
  29.                  // TODO Auto-generated catch block
  30.                  e.printStackTrace();
  31.              }
  32.          }
  33.          System.out.println(t.count);
  34.      }
  35.  }

三, AtomicXXX

Atomic 主要做的就是原子操作, 其中的每个方法都是原子操作, 可以保证线程安全. 参照下面的例子: 创建十个线程, 每个线程累加 100 次, 得到的结果就是 1000

  1. package cn.test.atomic;
  2.  import java.util.ArrayList;
  3.  import java.util.List;
  4.  import java.util.concurrent.atomic.AtomicInteger;
  5.  public class TestAtomic01 {
  6.      AtomicInteger count = new AtomicInteger(0);
  7.      void m1(){
  8.          for(int i = 0; i < 100; i++){
  9.              /*if(count.get() < 1000)*/
  10.              count.incrementAndGet();
  11.          }
  12.      }
  13.      public static void main(String[] args) {
  14.          final TestAtomic01 t = new TestAtomic01();
  15.          List<Thread> threads = new ArrayList<>();
  16.          for(int i = 0; i < 10; i++){
  17.              threads.add(new Thread(new Runnable() {
  18.                  @Override
  19.                  public void run() {
  20.                      t.m1();
  21.                  }
  22.              }));
  23.          }
  24.          for(Thread thread : threads){
  25.              thread.start();
  26.          }
  27.          for(Thread thread : threads){
  28.              try {
  29.                  thread.join();
  30.              } catch (InterruptedException e) {
  31.                  // TODO Auto-generated catch block
  32.                  e.printStackTrace();
  33.              }
  34.          }
  35.          System.out.println(t.count.intValue());
  36.      }
  37.  }

四, CountDownLatch

  1. package cn.test.syn;
  2.  /**
  3.   * 门闩 - CountDownLatch
  4.   * 可以和锁混合使用, 或替代锁的功能.
  5.   * 在门闩未完全开放之前等待. 当门闩完全开放后执行.
  6.   * 避免锁的效率低下问题.
  7.   */
  8.  import java.util.concurrent.CountDownLatch;
  9.  import java.util.concurrent.TimeUnit;
  10.  public class Test {
  11.      CountDownLatch latch = new CountDownLatch(5);
  12.      void m1(){
  13.          try {
  14.              latch.await();// 等待门闩开放.
  15.          } catch (InterruptedException e) {
  16.              e.printStackTrace();
  17.          }
  18.          System.out.println("m1() method");
  19.      }
  20.      void m2(){
  21.          for(int i = 0; i < 10; i++){
  22.              if(latch.getCount() != 0){
  23.                  System.out.println("latch count :" + latch.getCount());
  24.                  latch.countDown(); // 减门闩上的锁.
  25.              }
  26.              try {
  27.                  TimeUnit.MILLISECONDS.sleep(500);
  28.              } catch (InterruptedException e) {
  29.                  // TODO Auto-generated catch block
  30.                  e.printStackTrace();
  31.              }
  32.              System.out.println("m2() method :" + i);
  33.          }
  34.      }
  35.      public static void main(String[] args) {
  36.          final Test t = new Test();
  37.          new Thread(new Runnable() {
  38.              @Override
  39.              public void run() {
  40.                  t.m1();
  41.              }
  42.          }).start();
  43.          new Thread(new Runnable() {
  44.              @Override
  45.              public void run() {
  46.                  t.m2();
  47.              }
  48.          }).start();
  49.      }
  50.  }

来源: http://www.bubuko.com/infodetail-2970586.html


与本文相关文章

  1. JAVA 基础整理 - 100.Java 多线编程
  2. Java 并发编程 (02): 线程核心机制, 基础概念扩展
  3. Java 8 并发:同步和锁
  4. java 并发编程 | 线程详解
  5. [原创] Java 并发编程系列 2: 线程概念与基础操作
  6. Java 并发基础
  7. [Java 进阶] 并发编程
  8. Java 并发编程 (03): 多线程并发访问, 同步控制
暂无,快来抢沙发吧！
更多





黑ICP备17005318号-1