java并发编程入门:synchronized 与 Lock 的那点事

转载 2016年06月01日 15:42:19

此篇转载文章只说明了synchronized和Lock的应用,具体两者之间的区别,IBM这篇文章不错

http://www.ibm.com/developerworks/cn/java/j-jtp10264/index.html


synchronized和Lock应用举例转自:http://www.cnblogs.com/benshan/p/3551987.html

最近在做一个监控系统,该系统主要包括对数据实时分析和存储两个部分,由于并发量比较高,所以不可避免的使用到了一些并发的知识。为了实现这些要求,后台使用一个队列作为缓存,对于请求只管往缓存里写数据。同时启动一个线程监听该队列,检测到数据,立即请求调度线程,对数据进行处理。 具体的使用方案就是使用同步保证数据的正常,使用线程池提高效率。

 
同步的实现当然是采用锁了,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 如何实现呢?
 
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是个不错的方案。
 
 
-------------------------------<全文完>-------------------------------------------------------------------------------------------------------
 

相关文章推荐

MQ消息队列系列(1)为什么使用MQ

1.在高并发分布式环境下,由于来不及同步处理,请求往往发生堵塞,比如说,大量的insert、update之类的请求同时到达mysql,直接导致无所的行锁和表锁,甚至最后请求会堆积过多,从而触发too ...

MQ消息队列系列(2)什么时候使用MQ

1.跨语言应用集成 MQ使用java编写,并且提供一个java客户端API。但MQ也为C/C++,.NET,Perl,PHP,Python,Ruby等提供客户端。当你考虑在不同平台不同语言下的各个应用...

JAVA多线程3中实现总结

转自:http://www.cnblogs.com/yezhenhan/archive/2012/01/09/2317636.html JAVA多线程实现和应用总结 1 ...

java并发编程入门:synchronized 与 Lock 的那点事

此篇转载文章只说明了synchronized和Lock的应用,具体两者之间的区别,IBM这篇文章不错 http://www.ibm.com/developerworks/cn/java/j-jtp1...

synchronized 与 Lock 的那点事

最近在做一个监控系统,该系统主要包括对数据实时分析和存储两个部分,由于并发量比较高,所以不可避免的使用到了一些并发的知识。为了实现这些要求,后台使用一个队列作为缓存,对于请求只管往缓存里写数据。同时启...

JAVA并发编程:Synchronized和Lock

前言Java多线程编程中,保证线程安全通常会使用到synchronized和Lock。那么合适该使用synchronized,什么时候该使用Lock呢。这个就需要我们对synchronized和Loc...

java并发编程---synchronized和lock两种锁的比较

性能比较     在JDK1.5中,synchronized是性能低效的。因为这是一个重量级操作,它对性能最大的影响是阻塞的是实现,挂起线程和恢复线程的操作都需要转入内核态中完成,这些操作给系统的并...

java并发编程:线程安全-线程同步-synchronized和lock

多线程在提高效率的同时,必然面临线程安全的问题,Java中提供了一些机制来解决线程安全问题。 当多个线程同时访问临界资源(或叫共享资源)(一个对象,对象中的属性,一个文件,一个数据库等)时,就可能会产...

java并发编程---synchronized、Lock

1、引言 1.1 什么时候会出现线程安全问题?   在单线程中不会出现线程安全问题,而在多线程编程中,有可能会出现同时访问同一个资源的情况,这种资源可以是各种类型的的资源:一个变量、一个对象、一个文件...

【Java并发编程】对比synchronized和Lock

引言:在Java中,可以使用关键字synchronized来实现同步访问,从Java 5之后,在java.util.concurrent.locks包下提供了另外一种方式来实现同步访问,那就是Lock...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)