java多线程并发：Semaphore、volatile、synchronized及Lock

来源：长沙it培训|发布时间：2017-04-17|浏览量：

　　在java多线程并发编程中，我们通常会遇到以下三个问题：原子性问题，可见性问题，有序性问题。我们先看具体看一下这三个概念：

　　1.原子性

　　原子性：即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。

　　一个很经典的例子就是银行账户转账问题

　　2.可见性

　　可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。

　　3.有序性

　　有序性：即程序执行的顺序按照代码的先后顺序执行。

　　信号量(Semaphore)，有时被称为信号灯，是在多线程环境下使用的一种设施, 它负责协调各个线程, 以保证它们能够正确、合理的使用公共资源。

　　一个计数信号量。从概念上讲，信号量维护了一个许可集。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对可用许可的号码进行计数，并采取相应的行动。拿到信号量的线程可以进入代码，否则就等待。通过acquire()和release()获取和释放访问许可。

　　概念：Semaphore分为单值和多值两种，前者只能被一个线程获得，后者可以被若干个线程获得。

　　以一个停车场运作为例。为了简单起见，假设停车场只有三个车位，一开始三个车位都是空的。这时如果同时来了五辆车，看门人允许其中三辆不受阻碍的进入，然后放下车拦，剩下的车则必须在入口等待，此后来的车也都不得不在入口处等待。这时，有一辆车离开停车场，看门人得知后，打开车拦，放入一辆，如果又离开两辆，则又可以放入两辆，如此往复。

　　在这个停车场系统中，车位是公共资源，每辆车好比一个线程，看门人起的就是信号量的作用。

　　代码示例：

public class BeautySeekBarView extends View {     private Semaphore sePoolTH=new Semaphore(0);//信号量，解决并发问题 @Override     protected void onDraw(Canvas canvas) {         // TODO Auto-generated method stub         super.onDraw(canvas);         float PointX = 0;         float PointY=getHeight()/2;             canvas.drawLine(0+getPaddingLeft(),PointY, getWidth()-     //当绘制完成后释放信号，可以后续操作了         sePoolTH.release();     //设置默认位置     public void setPointLocation(final int location){         new Thread(new Runnable() {             @Override             public void run() {                              try {                  //等待信号，直到收到上面释放的信号了，开始进行一下逻辑                         sePoolTH.acquire();                     } catch (InterruptedException e) {                         // TODO Auto-generated catch block                         e.printStackTrace();                     }                           if(location>0&&pointList!=null&& !pointList.isEmpty()){                         bitmapPointX=pointList.get(location-1);                         postInvalidate();                     }             }         }).start();     }

　　volatile

　　1.volatile关键字的两层语义

　　一旦一个共享变量(类的成员变量、类的静态成员变量)被volatile修饰之后，那么就具备了一下语义：

　　1。保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。

　　2。禁止进行指令重排序。

　　3. 使用volatile关键字会强制将修改的值立即写入主存;

　　在 Java 垃圾回收整理一文中，描述了jvm运行时刻内存的分配。其中有一个内存区域是jvm虚拟机栈，每一个线程运行时都有一个线程栈，线程栈保存了线程运行时候变量值信息。当线程访问某一个对象时候值的时候，首先通过对象的引用找到对应在堆内存的变量的值，然后把堆内存变量的具体值load到线程本地内存中，建立一个变量副本，之后线程就不再和对象在堆内存变量值有任何关系，而是直接修改副本变量的值，在修改完之后的某一个时刻(线程退出之前)，自动把线程变量副本的值回写到对象在堆中变量。这样在堆中的对象的值就产生变化了。

　　对于volatile修饰的变量，jvm虚拟机只是保证从主内存加载到线程工作内存的值是最新的

　　例如假如线程1，线程2 在进行read,load 操作中，发现主内存中count的值都是5，那么都会加载这个最新的值

　　在线程1堆count进行修改之后，会write到主内存中，主内存中的count变量就会变为6

　　线程2由于已经进行read,load操作，在进行运算之后，也会更新主内存count的变量值为6

　　导致两个线程及时用volatile关键字修改之后，还是会存在并发的情况。

　　通常来说，使用volatile必须具备以下2个条件：

　　1)对变量的写操作不依赖于当前值

　　2)该变量没有包含在具有其他变量的不变式中。

　　synchronized

　　同步的实现当然是采用锁了，java中使用锁的两个基本工具是 synchronized 和 Lock。

　　一直很喜欢synchronized，因为使用它很方便。比如，需要对一个方法进行同步，那么只需在方法的签名添加一个synchronized关键字。

// 未同步的方法 public void test() {} // 同步的方法 pubilc synchronized void test() {} synchronized 也可以用在一个代码块上，看 public void test() {      synchronized(obj) {           System.out.println("===");      } }

　　synchronized 用在方法和代码块上有什么区别呢?

　　synchronized 用在方法签名上(以test为例)，当某个线程调用此方法时，会获取该实例的对象锁，方法未结束之前，其他线程只能去等待。当这个方法执行完时，才会释放对象锁。其他线程才有机会去抢占这把锁，去执行方法test,但是发生这一切的基础应当是所有线程使用的同一个对象实例，才能实现互斥的现象。否则synchronized关键字将失去意义。

　　(但是如果该方法为类方法，即其修饰符为static，那么synchronized 意味着某个调用此方法的线程当前会拥有该类的锁，只要该线程持续在当前方法内运行，其他线程依然无法获得方法的使用权!)

　　synchronized 用在代码块的使用方式：synchronized(obj){//todo code here}

　　当线程运行到该代码块内，就会拥有obj对象的对象锁，如果多个线程共享同一个Object对象，那么此时就会形成互斥!特别的，当obj == this时，表示当前调用该方法的实例对象。即

public void test() {      ...      synchronized(this) {           // todo your code      }      ... }

　　此时，其效果等同于

public synchronized void test() {      // todo your code }

 

　　使用synchronized代码块，可以只对需要同步的代码进行同步，这样可以大大的提高效率。

　　小结：

　　使用synchronized 代码块相比方法有两点优势：

　　1、可以只对需要同步的使用

　　2、与wait()/notify()/nitifyAll()一起使用时，比较方便

　　wait() 与notify()/notifyAll()

　　这三个方法都是Object的方法，并不是线程的方法!

　　wait():释放占有的对象锁，线程进入等待池，释放cpu,而其他正在等待的线程即可抢占此锁，获得锁的线程即可运行程序。而sleep()不同的是，线程调用此方法后，会休眠一段时间，休眠期间，会暂时释放cpu，但并不释放对象锁。也就是说，在休眠期间，其他线程依然无法进入此代码内部。休眠结束，线程重新获得cpu,执行代码。wait()和sleep()最大的不同在于wait()会释放对象锁，而sleep()不会!

　　notify(): 该方法会唤醒因为调用对象的wait()而等待的线程，其实就是对对象锁的唤醒，从而使得wait()的线程可以有机会获取对象锁。调用notify()后，并不会立即释放锁，而是继续执行当前代码，直到synchronized中的代码全部执行完毕，才会释放对象锁。JVM则会在等待的线程中调度一个线程去获得对象锁，执行代码。需要注意的是，wait()和notify()必须在synchronized代码块中调用。

　　notifyAll()则是唤醒所有等待的线程。

　　为了说明这一点，举例如下：

　　两个线程依次打印”A”“B”,总共打印10次。

public class Consumer implements Runnable {      @Override      public synchronized void run() {             // TODO Auto-generated method stub             int count = 10;             while(count > 0) {                  synchronized (Test. obj) {                      System. out.print( "B");                      count --;                      Test. obj.notify(); // 主动释放对象锁                       try {                            Test. obj.wait();                      } catch (InterruptedException e) {                             // TODO Auto-generated catch block                            e.printStackTrace();                      }                 }            }      } } public class Produce implements Runnable {      @Override      public void run() {             // TODO Auto-generated method stub             int count = 10;             while(count > 0) {                  synchronized (Test. obj) {                       //System.out.print("count = " + count);                      System. out.print( "A");                      count --;                      Test. obj.notify();                       try {                            Test. obj.wait();                      } catch (InterruptedException e) {                             // TODO Auto-generated catch block                            e.printStackTrace();                      }                 }            }      } }

　　测试类如下：

public class Test {      public static final Object obj = new Object();      public static void main(String[] args) {             new Thread( new Produce()).start();             new Thread( new Consumer()).start();      } }

　　这里使用static obj作为锁的对象，当线程Produce启动时(假如Produce首先获得锁，则Consumer会等待)，打印“A”后，会先主动释放锁，然后阻塞自己。Consumer获得对象锁，打印“B”，然后释放锁，阻塞自己，那么Produce又会获得锁，然后…一直循环下去，直到count = 0.这样，使用Synchronized和wait()以及notify()就可以达到线程同步的目的。

　　除了wait()和notify()协作完成线程同步之外，使用Lock也可以完成同样的目的。

　　ReentrantLock 与synchronized有相同的并发性和内存语义，还包含了中断锁等候和定时锁等候，意味着线程A如果先获得了对象obj的锁，那么线程B可以在等待指定时间内依然无法获取锁，那么就会自动放弃该锁。

　　但是由于synchronized是在JVM层面实现的，因此系统可以监控锁的释放与否，而ReentrantLock使用代码实现的，系统无法自动释放锁，需要在代码中finally子句中显式释放锁lock.unlock();

　　同样的例子，使用lock 如何实现呢?

　　lock

public class Consumer implements Runnable {      private Lock lock;      public Consumer(Lock lock) {             this. lock = lock;      }      @Override      public void run() {             // TODO Auto-generated method stub             int count = 10;             while( count > 0 ) {                  try {                       lock.lock();                      count --;                      System. out.print( "B");                 } finally {                       lock.unlock(); //主动释放锁                       try {                            Thread. sleep(91L);                      } catch (InterruptedException e) {                             // TODO Auto-generated catch block                            e.printStackTrace();                      }                 }            }      } } public class Producer implements Runnable{      private Lock lock;      public Producer(Lock lock) {             this. lock = lock;      }      @Override      public void run() {             // TODO Auto-generated method stub             int count = 10;             while (count > 0) {                  try {                       lock.lock();                      count --;                      System. out.print( "A");                 } finally {                       lock.unlock();                       try {                            Thread. sleep(90L);                      } catch (InterruptedException e) {                             // TODO Auto-generated catch block                            e.printStackTrace();                      }                 }            }      } }

　　调用代码：

public class Test {      public static void main(String[] args) {            Lock lock = new ReentrantLock();            Consumer consumer = new Consumer(lock);            Producer producer = new Producer(lock);             new Thread(consumer).start();             new Thread( producer).start();      } }

　　使用建议：

　　在并发量比较小的情况下，使用synchronized是个不错的选择，但是在并发量比较高的情况下，其性能下降很严重，此时ReentrantLock是个不错的方案。

上一篇：java架构设计：分布式文件系统

下一篇：Java Mybatis框架教程：功能架构