Java多线程：Lock的使用

最新推荐文章于 2023-04-27 16:57:21 发布
最新推荐文章于 2023-04-27 16:57:21 发布
阅读量158 收藏
点赞数
分类专栏： Java多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40473204/article/details/117172560
版权

ReentrantLock（某种程度上相当于synchronized，但是扩展了很多功能）

Condition实现等待/通知：

package com.java.mul;

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

public class Run {

	public static void main(String[] args) throws InterruptedException {
		// TODO Auto-generated method stub
		Service service = new Service();
		MyThreadA a = new MyThreadA(service);
		a.setName("A");
		a.start();
		
		
		MyThreadB b = new MyThreadB(service);
		b.setName("B");
		b.start();
		Thread.sleep(3000);
		service.signalAll_A();
		
		
			
	}
}

package com.java.mul;

public class MyThreadA extends Thread{
	private Service service;
	public MyThreadA(Service service) {
		super();
		this.service = service;
	}
	@Override
	public void run() {
		service.awaitA();
	}
}

package com.java.mul;

public class MyThreadB extends Thread{
	private Service service;
	public MyThreadB(Service service) {
		super();
		this.service = service;
	}
	@Override
	public void run() {
		service.awaitB();
	}
}

package com.java.mul;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Service {
	private Lock lock = new ReentrantLock();
	public Condition conditionA = lock.newCondition();
	public Condition conditionB = lock.newCondition();
	
	
	public void awaitA() {
		try {
			lock.lock();
			System.out.println("begin awaitA" + System.currentTimeMillis() + " Thread="+Thread.currentThread().getName());
			conditionA.await();
			System.out.println("end awaitA" + System.currentTimeMillis() + " Thread="+Thread.currentThread().getName());
			
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			lock.unlock();
		}
	}
	
	public void awaitB() {
		try {
			lock.lock();
			System.out.println("begin awaitB" + System.currentTimeMillis() + " Thread="+Thread.currentThread().getName());
			conditionB.await();
			System.out.println("end awaitB" + System.currentTimeMillis() + " Thread="+Thread.currentThread().getName());
			
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			lock.unlock();
		}
	}

	public void signalAll_A() {
		
		try {
			lock.lock();
			System.out.println("  signalAll_A time " + System.currentTimeMillis()+ " Thread="+Thread.currentThread().getName());
			conditionA.signalAll();
		}finally {
			lock.unlock();
		}
	}
	
	public void signalAll_B() {
		
		try {
			lock.lock();
			System.out.println("  signalAll_B time " + System.currentTimeMillis()+ " Thread="+Thread.currentThread().getName());
			conditionB.signalAll();
		} finally {
			lock.unlock();
		}
	}

}

实现生产者/消费者模式：一对一交替打印

package com.java.mul;

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

public class Run {

	public static void main(String[] args) throws InterruptedException {
		// TODO Auto-generated method stub
		Service service = new Service();
		
		MyThreadA a = new MyThreadA(service);
		a.setName("A");
		a.start();
		
		MyThreadB b = new MyThreadB(service);
		b.setName("B");
		b.start();
		
	}
}


package com.java.mul;

public class MyThreadA extends Thread{
	private Service service;
	public MyThreadA(Service service) {
		super();
		this.service = service;
	}
	@Override
	public void run() {
		for(int i=0;i<Integer.MAX_VALUE;i++) {
			service.set();
		}
		
	}
}


package com.java.mul;

public class MyThreadB extends Thread{
	private Service service;
	public MyThreadB(Service service) {
		super();
		this.service = service;
	}
	@Override
	public void run() {
		for(int i=0;i<Integer.MAX_VALUE;i++) {
			service.get();
		}
	}
}


package com.java.mul;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Service {
	private Lock lock = new ReentrantLock();
	public Condition condition = lock.newCondition();
	private boolean hasValue = false;
	
	public void set() {
		
		try {
			lock.lock();
			while(hasValue == true) {
				condition.await();
			}
			System.out.println("print 8");
			hasValue = true;
			condition.signal();
			
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public void get() {
		try {
			lock.lock();
			while(hasValue == false) {
				condition.await();
			}
			System.out.println("print o0o0");
			hasValue = false;
			condition.signal();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	

}

实现生产者/消费者模式：多对多交替打印

package com.java.mul;

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

public class Run {

	public static void main(String[] args) throws InterruptedException {
		// TODO Auto-generated method stub
		Service service = new Service();
		MyThreadA[] threadA = new MyThreadA[10];
		MyThreadB[] threadB = new MyThreadB[10];
		
		for(int i = 0;i<10;i++) {
			threadA[i] = new MyThreadA(service);
			threadB[i] = new MyThreadB(service);
			threadA[i].start();
			threadB[i].start();
			
		}
		
		
	}
}

package com.java.mul;

public class MyThreadA extends Thread{
	private Service service;
	public MyThreadA(Service service) {
		super();
		this.service = service;
	}
	@Override
	public void run() {
		for(int i=0;i<3;i++) {
			service.set();
		}
		
	}
}

package com.java.mul;

public class MyThreadB extends Thread{
	private Service service;
	public MyThreadB(Service service) {
		super();
		this.service = service;
	}
	@Override
	public void run() {
		for(int i=0;i<3;i++) {
			service.get();
		}
	}
}
package com.java.mul;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Service {
	private ReentrantLock lock = new ReentrantLock();
	public Condition condition = lock.newCondition();
	private boolean hasValue = false;
	
	public void set() {
		
		try {
			lock.lock();
			while(hasValue == true) {
				System.out.println("maybe continuas print 8");
				condition.await();
			}
			System.out.println("print 8");
			hasValue = true;
			condition.signalAll();
			
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public void get() {
		try {
			lock.lock();
			while(hasValue == false) {
				System.out.println("maybe continuas print o0o0");
				condition.await();
			}
			System.out.println("print o0o0");
			hasValue = false;
			condition.signalAll();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	

}



print 8
maybe continuas print 8
print o0o0
maybe continuas print o0o0
print 8
print o0o0
print 8
maybe continuas print 8
maybe continuas print 8
print o0o0
maybe continuas print o0o0
print 8
maybe continuas print 8
print o0o0
maybe continuas print o0o0
maybe continuas print o0o0
print 8
maybe continuas print 8
maybe continuas print 8
print o0o0
maybe continuas print o0o0
print 8
maybe continuas print 8
print o0o0
print 8
maybe continuas print 8
print o0o0
print 8
maybe continuas print 8
maybe continuas print 8
print o0o0
maybe continuas print o0o0
print 8
maybe continuas print 8
maybe continuas print 8
maybe continuas print 8
print o0o0
print 8
maybe continuas print 8
maybe continuas print 8
maybe continuas print 8
print o0o0
maybe continuas print o0o0
print 8
maybe continuas print 8
maybe continuas print 8
maybe continuas print 8
maybe continuas print 8
print o0o0
maybe continuas print o0o0
print 8
maybe continuas print 8
maybe continuas print 8
maybe continuas print 8
maybe continuas print 8

多对多，输出print 后紧跟的为什么是continus，一直没想明白。

 

公平锁与非公平锁

 

 

BinaryJack
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java多线程Lock的使用。
繁城落叶
05-06 1922
在Java多线程中，可以使用synchronized关键字来实现线程之间的同步互斥，也就是上锁。在JDK1.5之中，新增了ReentrantLock类也能够达到相同的效果。并且在扩展功能上更强、更加灵活。Lock。Lock是一个接口，也就是ReentrantLock以及ReentrantReadWriteLock.ReadLock、ReentrantReadWriteLock.WriteLock的的
Java 多线程之Lock的用法
Chennyken
05-03 453
        Lock 为线程加锁解锁,因为多个线程在访问同一个资源时,一个资源不能同时给两个线程进行读写操作. 所以使用线程同步的方式来对资源进行访问限制.        下面来看Lock的用法(使用流程):    1. 创建ReentrantLock对象, 首先,这个ReentrantLock类(重入锁),是一种递归无阻塞的同步机制的一个类.        创建方式如下:          ...
java多线程-lock的使用
qq_32844875的博客
05-16 503
        Lock就是使用ReentrantLock类，是在jdk1.5添加的类。相对比synchronized关键字有更加强大的功能，比如多路分支通知、读写锁控等等，更加灵活。     1.1最简单的lock使用 public class LockTest { private Lock lock = new ReentrantLock(); public void loc...
Java多线程中Lock的使用
crg18438610577的博客
04-27 877
Java多线程中Lock的使用
java多线程之-----Lock的使用
简国堂的博客
10-30 1250
写这个主要是在魅族面试的时候被问到多线程同步的问题，我打可以使用Lock，但是那个面试官却说java中没有Lock这个东西。我一开始坚定有，后来只好说没有了。主要是自己只是看过，了解。不过这个面试也让自己知道了很多的不足吧。结果还没出，应该是挂了。正题，在java多线程中，可以利用synchronized关键字来实现线程之间同步互斥，但在java1.5后，新增加了ReentranLock类也能达到同
Java多线程中Lock锁的使用总结
08-18
Java多线程中Lock锁的使用总结 Java多线程中Lock锁的使用总结主要介绍了Java多线程中Lock锁的使用总结，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值。 知识点1: Java多线程中的...
Java多线程基础——Lock类
08-31
Java多线程基础中的Lock类提供了比`synchronized`更强大的同步控制能力。Lock是一个接口，它定义了比`synchronized`更灵活的锁定机制，允许更细粒度的控制。在Java 1.5及之后的版本中引入，Lock类的主要目的是提高...
Java多线程编程之Lock用法实例
09-03
// 解锁 } }}在Java多线程编程中，`Lock`接口是Java并发包(`java.util.concurrent.locks`)提供的一个高级锁机制，相较于传统的`synchronized`关键字，`Lock`提供了更细粒度的锁控制和更多的特性。`Lock`接口提供了...
Java Lock锁多线程中实现流水线任务
08-19
Java Lock锁多线程中实现流水线任务是Java多线程编程中非常重要的一个主题。在多线程编程中，如何保证线程安全和避免死锁是两个主要的问题。Java提供了多种方式来解决这些问题，包括使用synchronized关键字、Lock...
Java多线程.pdf
09-28
总结来说，Java多线程技术包括线程的创建、线程安全的保证以及线程池的使用。熟练掌握这些知识点对于开发高效、稳定的多线程应用程序至关重要。通过合理地使用线程和线程池，我们可以有效地利用系统资源，提高程序的...
SpringBootLock:SpringBoot的各种锁(乐观锁、悲观锁、分布式锁)
05-26
项目中的常用的锁（乐观锁、悲观锁、基于Redis的分布式锁） 乐观锁 一般通过使用sql来做如添加版本之类的字段来做控制 例：select * from table where version = ?。保证都是一个线程在做更新。 悲观锁 锁住操作的资源，在数据库层面保证每次提交或回滚后才能进行下一步操作，例：查询时使用select * from table for update 分布式锁 使用Redis实现的分布式锁
spring boot中多线程开发的注意事项总结
08-26
spring boot 通过任务执行器 taskexecutor 来实现多线程和并发编程。下面这篇文章主要给大家介绍了关于spring boot中多线程开发的注意事项，文中通过示例代码介绍的非常详细，需要的朋友可以参考下
Java多线程_Lock的使用
qq_42148307的博客
10-28 239
文章目录ReentrantLock类ReentrantLock类的使用使用Condition实现等待|通知生产者和消费者模式公平锁与非公平锁使用ReentrantReadWriteLock类读读共享 ReentrantLock类 ReentrantLock类的使用 package multiply.com.test; public class Run { public static void main(String[] args) throws InterruptedException {
【java高级】多线程---Lock锁的使用
v1xiaolin的博客
11-17 694
目录 一：Lock锁 三：synchronized与Lock的对比 四：常见面试题： 五：优先使用顺序 一：Lock锁 从JDK5.0开始，java提供了更强大的线程同步机制--通过显式定义同步锁对象来实现同步，同步锁使用Lock对象充当。 ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现多线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁 二：Lock代码演示： class Windo.
Java多线程详解（九）------ Lock的使用
naruto227的博客
12-18 140
文章目录1 使用ReentrantLock类1.1 使用Condition实现等待/通知1.2 实现生产者/消费者1.3 公平锁与非公平锁1.4 部分API介绍1.5 交替打印ABC2 使用ReentrantReadWriteLock类 ReentrantLock类的使用 ReentrantReadWriteLock类的使用 1 使用ReentrantLock类 ReentrantLock类也能达到同样的效果，实现线程之间同步互斥，并且在扩展功能上也更加强大，比如具有嗅探锁定、多路分支通知等，使用上也比
Java多线程学习（五）Lock锁的使用
陈东东的博客
11-01 415
Lock接口 1.Lock接口介绍 锁是用于通过多个线程控制对共享资源的访问的工具。通常，锁提供对共享资源的独占访问：一次只能有一个线程可以获取锁，并且对共享资源的所有访问都要求首先获取锁。 但是，一些锁可能允许并发访问共享资源，如ReadWriteLock的读写锁。 在Lock接口出现之前，Java程序是靠synchronized关键字实现锁功能的。JDK1.5之后并发包中新增了Lock接口以...
java多线程lock()_Java多线程学习（六）——Lock的使用
weixin_36368932的博客
02-12 217
锁是用于通过多个线程控制对共享资源的访问的工具。通常，锁提供对共享资源的独占访问：一次只能有一个线程可以获取锁，并且对共享资源的所有访问都要求首先获取锁。 但是，一些锁可能允许并发访问共享资源，如ReadWriteLock的读写锁。Java5之后并发包中新增了Lock接口以及相关实现类来实现锁功能。虽然synchronized方法和语句的范围机制使得使用监视器锁更容易编程，并且有助于避免涉及锁的许...
Java多线程编程六(使用Lock)
qq_33225399的博客
03-02 418
线程间的通信一、等待和通知机制1.经过前面的知识学习，我们先来看一下如果才能让两个线程互相通信数据呢？ 本文主要讲述如何解决非线程安全问题，感谢java多线程核心编程一书，为本系列文章提供参考借鉴 一、等待和通知机制 1.经过前面的知识学习，我们先来看一下如果才能让两个线程互相通信数据呢？ ...
java如何使用线程锁的_Java多线程之Lock的使用（一）
weixin_34174789的博客
02-25 326
Java多线程中，可以使用synchronized关键字实现线程之间同步互斥，JDK1.5中新增加了ReentrantLock类也可以达到同样的效果，并且更加强大。如何使用class MyService {private var lock: Lock = ReentrantLock()fun testMethod() {lock.lock() //获取锁for (i in 1..5) {print...
Java多线程-避免同步机制带来的死锁问题及用Lock锁解决线程安全问题
最新发布
02-02
在Java多线程编程中，死锁是一种常见的并发问题，当多个线程相互等待对方释放资源而陷入僵局时，就会发生死锁。死锁通常由以下原因导致： 1. **线程之间的资源竞争**：当两个或更多线程各自持有部分资源，并且都在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值