互斥锁和信号量都是操作系统中为并发编程设计基本概念，互斥锁和信号量的概念上的不同在于，对于同一个资源，互斥锁只有0和1 的概念，而信号量不止于此。也就是说，信号量可以使资源同时被多个线程访问，而互斥锁同时只能被一个线程访问
互斥锁在java中的实现就是 reetranlock , 在访问一个同步资源时，它的对象需要通过方法 trylock() 获得这个锁，如果失败，返回 false，成功返回true。根据返回的信息来判断是否要访问这个被同步的资源。看下面的例子
我要评论
public class reentranlockexample {
private static int count = 0;
private static reentrantlock reentrantlock = new reentrantlock();
static class mythread extends thread{
@override
public void run() {
super.run();
try {
while (true){
boolean result = reentrantlock.trylock();
if (result){
system.out.println(thread.currentthread().getname() + "get the lock success and run the syn code " + count ++);
reentrantlock.unlock();
}else{
system.out.println(thread.currentthread().getname() + "get the lock failed and run the syn code " + count);
}
system.out.println(thread.currentthread().getname() + "run the asyntronized code " + count);
thread.sleep(500);
}
} catch (interruptedexception e) {
e.printstacktrace();
}
}
}
public static void main(string[] args){
mythread thread1 = new mythread();
mythread thread2 = new mythread();
thread1.start();
thread2.start();
}
}
信号量相当于一个计数器，如果线程想要访问某个资源，则先要获得这个资源的信号量，并且信号量内部的计数器减1 ，信号量内部的计数器大于0则意味着有可以使用的资源,当线程使用完某个资源时，必须释放这个资源的信号量。信号量的一个作用就是可以实现指定个线程去同事访问某个资源。只需要在初始化 。
信号量在 java中的实现是 semaphore ，其在初始化时传入一个整型数， 用来指定同步资源最大的并发访问量
public class semaphoreexample {
private static semaphore semaphore = new semaphore(2);
private string lock = "lock";
private static int count = 0;
static class mythread extends thread {
@override
public void run() {
super.run();
try {
while (true) {
semaphore.acquire();
thread.sleep(500);
system.out.println(thread.currentthread().getname() + "get the lock success and run the syn code " + count++);
semaphore.release();
thread.sleep(500);
}
} catch (interruptedexception e) {
e.printstacktrace();
}
}
}
public static void main(string[] args){
mythread thread1 = new mythread();
mythread thread2 = new mythread();
mythread thread3 = new mythread();
thread1.start();
thread2.start();
thread3.start();
}
}
countdownlatch 实现一个等待机制，在诸如 等待与会者到达后，开始会议的使用中。conutdownlatch 在初始化中一个计数器，用来指定需要等待的个数。在并发编程中，所解决的需求就是，等待所有的线程到达某个点后。才开始进行下一步，有点类似于开会，只有当所有的与会人员都到齐后，会议才能开始
public class countdownlatchexample {
private static countdownlatch mcountdownlatch = new countdownlatch(3);
static class mythread extends thread {
int awaittime;
public mythread(int i) {
this.awaittime = i;
}
@override
public void run() {
super.run();
try {
while (true) {
thread.sleep(awaittime);
system.out.println(thread.currentthread().getname() + "arrived " );
mcountdownlatch.countdown();
mcountdownlatch.await(); //可以指定等待时间
system.out.println(thread.currentthread().getname() + "start meeting " );
}
} catch (interruptedexception e) {
e.printstacktrace();
}
}
}
public static void main(string[] args){
mythread thread1 = new mythread(500);
mythread thread2 = new mythread(1000);
mythread thread3 = new mythread(2000);
thread1.start();
thread2.start();
thread3.start();
}
}
总结
以上就是本文有关java编程中的互斥锁,信号量和多线程等待机制实例详解的全部内容，希望对大家有所帮助。
有兴趣的朋友可以了解：java多线程卖票实例、java多线程并发编程(互斥锁reentrant lock)等。
如对本文有疑问， 点击进行留言回复！！
关于在IDEA中SpringBoot项目中activiti工作流的使用详解
视频编辑工具ACDSee Luxea Video Editor安装及激活图文教程
java spring整合junit操作(有详细的分析过程)
网友评论