Lock和Synchronized的比较

Lock接口

Lock接口可以实现和Synchronized相同的功能, 但是Lock可以实例化为一个对象, 更加体现面向对象的思想, 基本使用方法如下:

     Lock l = ...;
     l.lock();
     try {
         // access the resource protected by this lock
     } finally {
         l.unlock();
     }

示例代码:

 1 public class Test {
 2
 3     public static void main(String[] args) {
 4         new Test().init();
 5     }
 6
 7     private void init(){
 8         Outputer outputer = new Outputer();
 9         //新建第一个线程
10         new Thread(new Runnable(){
11             public void run() {
12                 while(true){
13                     try {
14                         Thread.sleep(10);
15                     } catch (InterruptedException e) {
16                         e.printStackTrace();
17                     }
18                     outputer.output("shen_smile");
19                 }
20             }
21         }).start();
22         //新建第二个线程
23         new Thread(new Runnable(){
24             public void run() {
25                 while(true){
26                     try {
27                         Thread.sleep(10);
28                     } catch (InterruptedException e) {
29                         e.printStackTrace();
30                     }
31                     outputer.output("LockTest");
32                 }
33             }
34         }).start();
35     }
36     //静态内部类
37     static class Outputer{
38         Lock lock = new ReentrantLock();//新建一个锁对象
39         public void output(String name){
40             int len = name.length();
41             lock.lock();
42             try{
43                 for(int i=0;i<len;i++){
44                     System.out.print(name.charAt(i));
45                 }
46                 System.out.println();
47             }finally{
48                 lock.unlock();
49             }
50         }
51         //用synchronized实现代码段的互斥调用
52         public synchronized void output2(String name){
53             int len = name.length();
54             for(int i=0;i<len;i++){
55                 System.out.print(name.charAt(i));
56             }
57             System.out.println();
58         }
59     }
60 }

总结:

1. 当两个线程都使用同一个Outputer类的对象的同一个output方法时, 各个线程之间就能实现互斥调用

2. Lock和 Synchronized具有相同的功能, 但是 Lock比 Synchronized更加体现面向对象的思想, 因为锁本身就是一个对象

时间: 2024-10-27 06:23:57

Lock和Synchronized的比较的相关文章

Lock和synchronized

Lock和synchronized有以下几点不同: 1)Lock是一个接口,而synchronized是Java中的关键字,synchronized是内置的语言实现: 2)synchronized在发生异常时,会自动释放线程占有的锁,因此不会导致死锁现象发生:而Lock在发生异常时,如果没有主动通过unLock()去释放锁,则很可能造成死锁现象,因此使用Lock时需要在finally块中释放锁: 3)Lock可以让等待锁的线程响应中断,而synchronized却不行,使用synchronize

Lock与synchronized 的区别

1.ReentrantLock 拥有Synchronized相同的并发性和内存语义,此外还多了 锁投票,定时锁等候和中断锁等候 线程A和B都要获取对象O的锁定,假设A获取了对象O锁,B将等待A释放对O的锁定, 如果使用 synchronized ,如果A不释放,B将一直等下去,不能被中断 如果 使用ReentrantLock,如果A不释放,可以使B在等待了足够长的时间以后,中断等待,而干别的事情 ReentrantLock获取锁定与三种方式:    a)  lock(), 如果获取了锁立即返回,

Lock较synchronized多出的特性

1.尝试非阻塞形式获取锁 tryLock() :当前线程尝试获取锁,如果锁被占用返回false;如果成功则占有锁 //类似用法if(lock.tryLock()) { try { System.out.println(thread.getName()+"得到了锁"); for(int i=0;i<5;i++) { arrayList.add(i); } } catch (Exception e) { // TODO: handle exception }finally { Sys

Java并发编程:Lock和Synchronized &lt;转&gt;

在上一篇文章中我们讲到了如何使用关键字synchronized来实现同步访问.本文我们继续来探讨这个问题,从Java 5之后,在java.util.concurrent.locks包下提供了另外一种方式来实现同步访问,那就是Lock. 也许有朋友会问,既然都可以通过synchronized来实现同步访问了,那么为什么还需要提供Lock?这个问题将在下面进行阐述.本文先从synchronized的缺陷讲起,然后再讲述java.util.concurrent.locks包下常用的有哪些类和接口,最后

Lock和synchronized使用

该文章主要讲解如何快速应用Lock和synchronized 读者可以自行学习Lock和synchronized系统级比较:可参考并发实战等,自己决定什么场景下使有哪种锁 Lock使用案例: public class Person { //两个线程同时调用这个方法 public void say(String msg){ int len = msg.length(); for(int i=0;i<len;i++){ System.out.print(msg.charAt(i)); } Syste

Lock和synchronized比较详解(转)

从Java5之后,在java.util.concurrent.locks包下提供了另外一种方式来实现同步访问,那就是Lock. 也许有朋友会问,既然都可以通过synchronized来实现同步访问了,那么为什么还需要提供Lock?这个问题将在下面进行阐述.本文先从synchronized的缺陷讲起,然后再讲述java.util.concurrent.locks包下常用的有哪些类和接口,最后讨论以下一些关于锁的概念方面的东西 以下是本文目录大纲: 一.synchronized的缺陷 二.java.

(转)Lock和synchronized比较详解

在上一篇文章中我们讲到了如何使用关键字synchronized来实现同步访问.本文我们继续来探讨这个问题,从Java5之后,在java.util.concurrent.locks包下提供了另外一种方式来实现同步访问,那就是Lock. 也许有朋友会问,既然都可以通过synchronized来实现同步访问了,那么为什么还需要提供Lock?这个问题将在下面进行阐述.本文先从synchronized的缺陷讲起,然后再讲述java.util.concurrent.locks包下常用的有哪些类和接口,最后讨

Lock和synchronized的选择

学习资源:http://www.cnblogs.com/dolphin0520/p/3923167.html 一.java.util.concurrent.locks包下常用的类 1.Lock public interface Lock {     void lock();//用来获取锁.如果锁已被其他线程获取,则进行等待.     void lockInterruptibly() throws InterruptedException;//当通过这个方法去获取锁时,如果线程正在等待获取锁,则这

lock和synchronized的区别

与synchronized类似的,lock也能够达到同步的效果 Lock是一个接口,为了使用一个Lock对象,需要用到 Lock lock = new ReentrantLock(): lock必须调用unlock方法进行手动释放,为了保证释放的执行,往往会把unlock() 放在finally中进行. synchronized 是不占用到手不罢休的,会一直试图占用下去.与 synchronized 的钻牛角尖不一样,Lock接口还提供了一个trylock方法.trylock会在指定时间范围内试