java多线程并发(一)——Semaphore,volatile,synchronized ,Lock

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

1.原子性

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

一个很经典的例子就是银行账户转账问题
2.可见性

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

3.有序性

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

Semaphore

简介
信号量(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是个不错的方案。

此系列更多文章目前还在CSDN: http://blog.csdn.net/King1425/article/category/6814582 敬请关注

推荐阅读更多精彩内容

  • 从三月份找实习到现在,面了一些公司,挂了不少,但最终还是拿到小米、百度、阿里、京东、新浪、CVTE、乐视家的研发岗...
    时芥蓝阅读 34,521评论 9 329
  • Java8张图 11、字符串不变性 12、equals()方法、hashCode()方法的区别 13、...
    Miley_MOJIE阅读 2,284评论 0 10
  • 一:java概述:1,JDK:Java Development Kit,java的开发和运行环境,java的开发工...
    ZaneInTheSun阅读 1,384评论 0 9
  • 1. Java基础部分 基础部分的顺序:基本语法,类相关的语法,内部类的语法,继承相关的语法,异常的语法,线程的语...
    会飞的鱼69阅读 24,931评论 18 393
  • 一直以来这是我第五次在这里写东西了 也是最后一次为你写了 我们之间发生了太多太多的事了 有开心的 不开心...
    唯有你爱阅读 228评论 0 0