java5 中的锁的用法 Lock lock = new ReentrantLock();

最新推荐文章于 2024-07-24 21:47:59 发布
最新推荐文章于 2024-07-24 21:47:59 发布
阅读量845 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/mxyhws/p/3957220.html
版权

public class LockTest {

 

         /**

          * @param args

          */

         public static void main(String[] args) {

                   new LockTest().init();

         }

        

         private void init(){

                   final Outputer outputer = new Outputer();

                   new Thread(new Runnable(){

                            @Override

                            public void run() {

                                     while(true){

                                               try {

                                                        Thread.sleep(10);

                                               } catch (InterruptedException e) {

                                                        // TODO Auto-generated catch block

                                                        e.printStackTrace();

                                               }

                                               outputer.output("zhangxiaoxiang");

                                     }

                                    

                            }

                   }).start();

                  

                   new Thread(new Runnable(){

                            @Override

                            public void run() {

                                     while(true){

                                               try {

                                                        Thread.sleep(10);

                                               } catch (InterruptedException e) {

                                                        // TODO Auto-generated catch block

                                                        e.printStackTrace();

                                               }

                                               outputer.output("lihuoming");

                                     }

                                    

                            }

                   }).start();

                  

         }

 

         static class Outputer{

                   Lock lock = new ReentrantLock();

                   public void output(String name){

                            int len = name.length();

                            lock.lock();

                            try{

                                     for(int i=0;i<len;i++){

                                               System.out.print(name.charAt(i));

                                     }

                                     System.out.println();

                            }finally{

                                     lock.unlock();

                            }

                   }

                  

                   public synchronized void output2(String name){

                            int len = name.length();

                            for(int i=0;i<len;i++){

                                               System.out.print(name.charAt(i));

                            }

                            System.out.println();

                   }

                  

                   public static synchronized void output3(String name){

                            int len = name.length();

                            for(int i=0;i<len;i++){

                                               System.out.print(name.charAt(i));

                            }

                            System.out.println();

                   }       

         }

}

 

读写锁  ReadWriteLock rwl = new ReentrantReadWriteLock();

 

public class ReadWriteLockTest {

         public static void main(String[] args) {

                   final Queue3 q3 = new Queue3();

                   for(int i=0;i<3;i++)

                   {

                            new Thread(){

                                     public void run(){

                                               while(true){

                                                        q3.get();                                                

                                               }

                                     }

                                    

                            }.start();

 

                            new Thread(){

                                     public void run(){

                                               while(true){

                                                        q3.put(new Random().nextInt(10000));

                                               }

                                     }                          

                                    

                            }.start();

                   }

                  

         }

}

 

class Queue3{

         private Object data = null;//共享数据，只能有一个线程能写该数据，但可以有多个线程同时读该数据。

         ReadWriteLock rwl = new ReentrantReadWriteLock();

         public void get(){

                   rwl.readLock().lock();

                   try {

                            System.out.println(Thread.currentThread().getName() + " be ready to read data!");

                            Thread.sleep((long)(Math.random()*1000));

                            System.out.println(Thread.currentThread().getName() + "have read data :" + data);                   

                   } catch (InterruptedException e) {

                            e.printStackTrace();

                   }finally{

                            rwl.readLock().unlock();

                   }

         }

        

         public void put(Object data){

 

                   rwl.writeLock().lock();

                   try {

                            System.out.println(Thread.currentThread().getName() + " be ready to write data!");                           

 

                  

                            Thread.sleep((long)(Math.random()*1000));

                            this.data = data;              

                            System.out.println(Thread.currentThread().getName() + " have write data: " + data);                          

 

                  

                   } catch (InterruptedException e) {

                            e.printStackTrace();

                   }finally{

                            rwl.writeLock().unlock();

                   }

                  

        

         }

}

 

 

转载于:https://www.cnblogs.com/mxyhws/p/3957220.html

weixin_30815427
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java中的锁--重入锁ReentrantLock
HAIMING157的博客
06-28 197
前言 在Java5.0之前，在协调对共享对象的访问时可以使用的机制只有synchronized和volatile。Java5.0增加了一种新的机制：ReentrantLock。ReentrantLock并不是一种替代内置加锁的方法，而是当内置锁机制不适用时，作为一种可选择的高级功能。 Lock与ReentrantLock 与内置加锁机制不同的是，Lock提供了一种无条件的、可轮询的、定时...
Java中的锁——ReentrantReadWriteLock(读写锁)
惟愿无事
12-21 2986
上一篇里讲的ReentrankLock是一种排他锁，即同一时间只能有一个线程进入。而读写锁在同一时刻允许多个读线程访问，但是在写线程访问时，所有的读线程和其他线程均被阻塞。读写锁维护了一对锁，一个读锁和一个写锁，通过分离读写锁，使得并发性比一般的排它锁有了很大提升。因为大多数应用场景都是读多于写的，因此在这样的情况下，读写锁可以提高吞吐量。下图描述了关于读写锁的三个特性：公平性、重入性和锁降级。
详解Lock锁
m0_60298929的博客
08-16 705
一.售票案例 1.传统synchronized实现 package com.yu.lock; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class Test2 { public static void main(String[] args) { Ticked ticked = new Ticked(); ...
11.Lock锁
khmff的博客
04-05 622
1.创建Lock锁对象的方式：使用实现类ReentrantLock创建Lock对象。 (1)Lock lock=new ReentrantLock(); 注：相当于synchronized(this)。 (2)static Lock lock=new ReentrantLock(); 注：相当于synchronized(类.class)。 import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.Reent
Java多线程-新特征-锁(上)
weixin_34281477的博客
07-25 173
在Java5中，专门提供了锁对象，利用锁可以方便的实现资源的封锁，用来控制对竞争资源并发访问的控制，这些内容主要集中在java.util.concurrent.locks 包下面，里面有三个重要的接口Condition、Lock、ReadWriteLock。 Condition: Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对...
线程基础（八）Reentrantlock重入锁
踟蹰千年的博客
01-18 250
ReentrantLock ReentrantLock，一个可重入的互斥锁，它具有与使用synchronized方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。 ReentrantLock基本用法 /** * 重入锁 */ public class ReentrantLockTest { int count =0; public static void mai...
并发编程——ReentrantLock
eyes++的博客
03-05 898
从Java 5开始，引入了一个高级的处理并发的包，它提供了大量更高级的并发功能，能大大简化多线程程序的编写。我们知道Java语言直接提供了synchronized关键字用于加锁，但这种锁一是很重，二是获取时必须一直等待，没有额外的尝试机制。而包提供的ReentrantLock用于替代synchronized加锁。
Java多线程 ReentrantLock互斥锁详解
08-25
在testMethod()方法中，我们首先使用lock.lock()方法来获取锁，然后执行一些操作，最后使用lock.unlock()方法来释放锁。 ReentrantLock的优点是可以重入，即一个线程可以多次获得锁，而不需要释放锁。这种机制可以...
Java线程同步Lock同步锁代码示例
08-28
Lock同步锁是Java 5提供的一个强大的线程同步机制，通过显示定义同步锁对象来实现同步。Lock可以显示的加锁、解锁。每次只能有一个线程对lock对象加锁。Lock有ReadLock、WriteLock、ReentrantLock（可重入锁）等多种...
浅谈Java并发编程之Lock锁和条件变量
08-18
Lock锁是Java并发编程中的一种重要机制，它提供了比synchronized更加广泛的锁定操作。Lock接口有三种实现类：ReentrantLock、ReetrantReadWriteLock.ReadLock和ReetrantReadWriteLock.WriteLock，即重入锁、读锁和...
Java多线程并发编程(互斥锁Reentrant Lock)
08-30
ReentrantLock 的用法非常简单，只需要在需要锁定的位置使用 lock() 方法，并在 finally 语句中使用 unlock() 方法释放锁。例如： ```java public class Test { private ReentrantLock mReentrantLock = new ...
java Lock接口详解及实例代码
08-31
Java Lock接口是Java并发编程中一个重要的组成部分，它提供了一种更为灵活的锁机制，相比传统的`synchronized`关键字，Lock接口允许我们进行更细粒度的控制，包括可中断的锁等待、尝试获取锁以及定时等待等。...
并发编程7-Lock锁系列 ReentrantLock
ming13849012515的博客
05-15 693
目录 前言 加锁目的 Lock 锁的继承体系 Lock 顶层接口分析 可重入锁ReentrantLock ReentrantLock 公平锁和非公平锁是什么？有什么区别？ ReentrantLock源码分析 类的继承关系 类的内部类 Sync类 NonfairSync类 FairSyn类 类的属性 类的构造函数 核心函数分析 应用示例： 参考推荐： 前言 加锁目的 序列化访问临界资源，即同一时刻只能有一个线程访问临界资源(同步互斥访问) 首先明确：Lock
Lock的使用（二）——使用ReentrantLock类
qq_44307209的博客
08-22 222
可以先对线程进行分组，然后再唤醒指定组中的线程。Object类中的 wait(long timeout)方法相当于Condition类中的await(long time,TimeUnit unit)方法。Object类中的notifyAll()方法相当于Condition类中的signalAll()方法。Object类中的notify()方法相当于Condition类中的signal()方法。Object类中的wait()方法相当于Condition类中的await()方法。成功实现等待/通知模式。
线程锁--普通锁 Lock lock = new ReentrantLock();
qq_28958027的博客
09-03 1530
https://blog.csdn.net/u014236541/article/details/50301163
Java并发编程知识点总结（十一）——ReentrantLock实现原理
XHHP
09-08 740
ReentrantLock意思为可重入锁，也就是能够多重加锁。并且加了多少次锁，也必须对应解锁多少次。此外，ReentrantLock支持公平锁和非公平锁，是基于AQS进行实现的。【基本功】不可不说的Java“锁”事公平锁：按照AQS的FIFO的同步队列的时间顺序获取锁，不会存在饥饿现象。非公平锁：有可能刚刚释放锁的线程又重新获得锁，可能会出现线程饥饿现象。下面我们来看下ReetrantLock和synchronizer之间的对比，如下图：AQS中实现了独占锁和共享锁的框架。
Java并发—java.util.concurrent.locks包
Rookie20190715的博客
08-28 291
Java并发—java.util.concurrent.locks包 一.synchronized的缺陷 synchronized是java中的一个关键字，也就是说是Java语言内置的特性。那么为什么会出现Lock呢？ 如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况：...
多线程(二) -- 管程(六) -- ReentrantLock详解
weixin_39724194的博客
07-16 767
概述： ReentrantLock，一个可重入的互斥锁，它具有与使用synchronized方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。 基本使用： public class ReentrantLockTest1 { private Lock lock = new ReentrantLock(); public void test() { try { lock.lock(); for (int i =
golang 接口
最新发布
m0_70982551的博客
07-24 812
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Lock lock = new ReentrantLock();
01-13
`Lock lock = new ...在上面的示例中，我们创建了一个`ReentrantLock`对象，并在`doSomething()`方法中使用`lock()`方法获取锁，然后在`try-finally`块中执行需要保护的代码，并在最后使用`unlock()`方法释放锁。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值