Java thread(4)
这一块主要是讨论关于进程同步的相关问题,主要是考虑一下的关键字:锁对象、条件对象 -> synchronized wait() notify()。
1、关于锁对象与条件对象:
所对象的定义在java中的java.util.concurrent.locks中Lock接口,具体可以有多种实现。对于lock()方法而言,通常的使用方法如下:
比如自己写的某个类已经实现了Lock接口,并且生成了一个实例myLock。之后用Lock接口的lock()方法来控制临界区的代码:
myLock.lock()//相当于获取了这个锁,如果锁同时被另一个线程拥有,则会发生阻塞
try
{
//临界区的代码
} finally
{
myLock.unlock()//放弃对这个锁的拥有权
}
这个用法感觉上就像是之前操作系统中的阻塞原语的用法一样,用P、V互斥信号量,把临界区的代码包在里面。
条件对象,这个条件对象的使用就像是之前PV操作中的同步原语一样,condition对象的声明方法也在java.util.concurrent.locks 接口中。使用newCondition()可以返回一个condition实例。
调用conditioninstance.await()方法之后,则当前线程会被阻塞,并且放弃了当前线程对锁的拥有权。
conditioninstance.signalAll()这个方法的调用会激活因为这一条件而等待的所有的线程,这些线程会从等待集中移除,变成再次可运行的。
通常与Lock结合起来使用:
myLock.Lock() try { While(某一个条件不满足的时候) conditioninstance.await(); //某一个条件符合之后 就会往下实行 … //相关的操作执行完成后 唤醒等待的线程 这些被唤醒的线程通过竞争实现访问 conditioninstance.await(); } finally { myLock.unlock(); }
2、synchronized 关键字以及 notify wait 的使用:
基本上来说,这个与上面的lock以及条件对象,所实现的功能是相同的。
比如说一个用synchronized关键字修饰的方法:
public synchronized void method()
{
Method body
}
这样的效果与使用 lock类似,相当于拥有了调用这个方法的一个对象的内部锁
public void method()
{
this.intrinsicLock.lock();
try
{
Method body
}
finally
{
this.intrinsicLock.unlock();
}
}
2.1、对于synchornized关键字的说明:
由于在多线程的环境中,可能会有两个或者更多的线程试图同时访问某一个资源,为了保证对于资源修改的有效性,以及修改不会引起冲突,必须采用一定的机制来控制线程对于某个资源的访问的权限。可以通过对临界代码加锁的方式来进行限制,即是前面提到的,采用锁对象的方式来进行限制。
每一个对象内置的都有一个锁或者是被称作monitor。被synchronized关键字修饰的方法叫做同步方法。当某个类的实例去访问这个实例的同步方法的时候,则被synchronized关键字修饰的方法相当于被对象的内部锁给包住了,通过synchronized关键字给这个方法上了锁,这个锁是这个对象本身的内置的锁,此时其他的任何一个线程都无法通过这个对象来直接访问这个方法,必须要等这个方法执行完后,将这个对象的内部的锁的拥有权释放,之后其他线程才能再通过这个对象来获执行synchronized方法。这样比起直接生成锁对象,再在最后解锁的方式要精简一些。
注意synchronized关键字要放在方法返回类型之前。
具体例子的代码:
package com.javase.thread; //这个主要是演示一下 synchornized方法 public class threadTest3 { public static void main(String []args){ synExample synexmple=new synExample(); Thread t1=new theThread(synexmple); Thread t2=new theThread(synexmple); t1.start(); t2.start(); } } class synExample{ public synchronized void excute() throws InterruptedException { for(int i=0;i<10;i++) { System.out.println("the number is "+ i); } return; } } class theThread extends Thread{ //注意这里要通过 synExample对象来调用excute方法 private synExample synexample; public theThread(synExample syn) { this.synexample=syn; } public void run() { try { this.synexample.excute(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } return; } }
这个加上了 synchronized 关键字之后,两个线程就会交替地执行 synExample 实例的excute方法,先出0-9,再出0-9。要是不加synrchonized关键字的话,就实现不了互斥访问excute关键字的效果,可能就是乱序输出。
特别注意一下,当Synchronized关键字修饰的是一个static方法的时候,此时通过synchronized关键字激活的是Class类对象的锁,并不是通过Class类生成的实例的锁。这样的话,任何相关线程通过这个class类对象来访问任何static synchornized方法(访问同一个类的static synchornized方法),都是可以实现互斥访问的。
2.2、关于synchornized块:
通过synchornized关键字来修饰一个方法,这样实现的一个互斥访问可能是粗粒度的,比如一个方法中只有某一部分需要同步,这样的话就需要用到synchrornized块来控制,表示对于块中的代码而言,某时刻只要有一个线程在执行就好。采用synchronized块的时候通常要设置一个私有的Object对象,这个Object对象没有什么实际的意义,只是用来提供一个可以使用的内部锁。
参考下面的例子:
package com.javase.synchronizedblock; public class blockTest { //这个主要是测试一下 关于synchornized块的信息 public static void main(String[]args){ //两个线程要访问同一个example类对象 Example example=new Example(); Thread t1=new threadExample1(example); Thread t2=new threadExample1(example); t1.start(); t2.start(); } } class Example{ private Object obj=new Object(); public void excute(){ int i; for(i=1;i<=10;i++) {System.out.println("the number is "+i);} synchronized(obj){ for(i=11;i<=20;i++){ try { Thread.sleep(100); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println("the number of synchronized block in excute is "+i); } } } } class threadExample1 extends Thread{ private Example example; //构造函数 public threadExample1(Example example){ this.example=example; } public void run() { example.excute(); } } 执行结果:
/*
the number is 1
the number is 2
the number is 1
the number is 3
the number is 2
the number is 4
the number is 3
the number is 5
the number is 4
the number is 6
the number is 5
the number is 7
the number is 6
the number is 8
the number is 7
the number is 9
the number is 8
the number is 10
the number is 9
the number is 10
the number of synchronized block in excute is 11
the number of synchronized block in excute is 12
the number of synchronized block in excute is 13
the number of synchronized block in excute is 14
the number of synchronized block in excute is 15
the number of synchronized block in excute is 16
the number of synchronized block in excute is 17
the number of synchronized block in excute is 18
the number of synchronized block in excute is 19
the number of synchronized block in excute is 20
the number of synchronized block in excute is 11
the number of synchronized block in excute is 12
the number of synchronized block in excute is 13
the number of synchronized block in excute is 14
the number of synchronized block in excute is 15
the number of synchronized block in excute is 16
the number of synchronized block in excute is 17
the number of synchronized block in excute is 18
the number of synchronized block in excute is 19
the number of synchronized block in excute is 20
*/
可以看出来,生成两个线程实例来访问通样一个Example对象,这个Example对象输出的1-10的部分没有加锁,11-20的部分被放在了synchronized块中,结果很显然,synchronized块中的部分实现了互斥访问,而外面的部分没有互斥访问,输出的顺序是混乱的。
注意synchornized块的调用方式:
直接 synchronized(obj) { 临界代码块 } 这样就ok 了。
2.3、关于wait与notify方法
wait与notify都是Object类中的方法,重要性显而易见,它们所实现的功能与之前的条件对象的功能是一致的。无论是wait与notify全需要在synchronized所修饰的方法或者方法块中进行调用,wait()方法与notify()方法总是成对出现的。
调用一个对象的wait方法的时候,该线程释放了对该对象的内部锁的拥有权,直到其他线程调用同一个对象的notify方法,原先的进程的wait状态就解除了等待,有重新竞争获得锁的资格了。注意wait方法与sleep方法的区别,虽然都是线程的等待状态,但是在sleep的时候,线程不会释放掉对锁的拥有权。
notify方法可以唤醒多个线程中的一个,这种唤醒是武断的随机选择的,每次只能唤醒一个,而notifyall方法是解除所有的在该对象上调用wait方法的线程的等待状态,使得所有的被唤醒的进程进入争夺锁的状态中,但最后只有一个线程可以重新获得锁, 一般就用notifyall因为notify有时候使用不当可能会发生死锁。
基本的线程的状态之间的转化关系可以参考下面的这个图:
一个利用notify 与 wait实现的银行账户存取钱的例子:
package com.javase.thread.waitnotify; public class bankTest { public static void main(String[]args){ //生成一个账户对象 bankAccount account=new bankAccount(); int i; //启动三个取钱的线程 for(i=1;i<3;i++) { Thread e=new threadExtract(account,i); e.start(); } //启动三个存钱的线程 for(i=2;i<5;i++) { Thread s=new threadSave(account,i); s.start(); } } } class bankAccount{ private int money=0; //取钱 public synchronized void extract(int number) throws InterruptedException { //要是账户钱不够的话 就不能取 要一直等待 存钱之后 才能再取 while(money<=number) {wait();} //当符合取钱的条件时 this.money-=number; System.out.println("取钱:"+number+" 当前账户的余额:"+money); } //存钱 public synchronized void save(int number) throws InterruptedException { //加入默认条件下 存钱没有上限 不管余额多少 都能存入 this.money+=number; System.out.println("存钱:"+number+" 当前账户的余额:"+money); //存入之后 唤醒 取钱的进程 notifyAll(); } } class threadSave extends Thread{ private bankAccount account; private int money; public threadSave(bankAccount accon,int savemoney) { account=accon; money=savemoney; } public void run(){ try { this.account.save(money); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } class threadExtract extends Thread{ private bankAccount account; private int money; public threadExtract(bankAccount accon,int extractmoney) { account=accon; money=extractmoney; } public void run(){ try { this.account.extract(money); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } /* 运行结果:
存钱:2 当前账户的余额:2
取钱:1 当前账户的余额:1
存钱:4 当前账户的余额:5
存钱:3 当前账户的余额:8
取钱:2 当前账户的余额:6
*/
这个例子主要就是在一个bank类里分别设置了存钱和取钱的方法,很重要的一点是在wait条件判断的那一部分要使用while而不能使用if 因为在线程很多的情况下,采用if往往会出问题,特别是在多个线程的时候,因为在这个线程wait的时候,其他线程可能已经对环境做了一些改变,这个时候还需要对条件进行重新检验。
虽然这个程序里线程的启动顺序是先取钱再存钱,但是并没有出现负数的情况,实际上是取钱进程在等待存钱进程执行完成后,才进行取钱操作。第一个打印出来的肯定是存钱,但是后面几个线程执行顺序就不确定了,每次运行的结果可能都不一样,但是可以保证的是,取钱的数目要小于账户的余额。
Java thread(4)的更多相关文章
- Java Thread 的 sleep() 和 wait() 的区别
Java Thread 的使用 Java Thread 的 run() 与 start() 的区别 Java Thread 的 sleep() 和 wait() 的区别 1. sleep ...
- Java Thread 的 run() 与 start() 的区别
Java Thread 的使用 Java Thread 的 run() 与 start() 的区别 Java Thread 的 sleep() 和 wait() 的区别 1. ...
- Java Thread wait, notify and notifyAll Example
Java Thread wait, notify and notifyAll Example Java线程中的使用的wait,notify和nitifyAll方法示例. The Object clas ...
- java: Thread 和 runnable线程类
java: Thread 和 runnable线程类 Java有2种实现线程的方法:Thread类,Runnable接口.(其实Thread本身就是Runnable的子类) Thread类,默认有ru ...
- Java Thread join() 的用法
Java Thread中, join() 方法主要是让调用改方法的thread完成run方法里面的东西后, 在执行join()方法后面的代码.示例: class ThreadTesterA imple ...
- Java thread jargon
In Java thread topic, the task to be executed and the thread to drive the task are two concepts shou ...
- 性能分析之-- JAVA Thread Dump 分析综述
性能分析之-- JAVA Thread Dump 分析综述 一.Thread Dump介绍 1.1什么是Thread Dump? Thread Dump是非常有用的诊断Java应用问题的工 ...
- Java Thread线程控制
一.线程和进程 进程是处于运行中的程序,具有一定的独立能力,进程是系统进行资源分配和调度的一个独立单位. 进程特征: A.独立性:进程是系统中独立存在的实体,可以拥有自己独立的资源,每个进程都拥有自己 ...
- [译]Java Thread wait, notify和notifyAll示例
Java Thread wait, notify和notifyAll示例 Java上的Object类定义了三个final方法用于不同线程间关于某资源上的锁状态交互,这三个方法是:wait(), not ...
- [译]Java Thread Sleep示例
Java Thread Sleep示例 java.lang.Thread sleep(long millis)方法被用来暂停当前线程的执行,暂停时间由方法参数指定,单位为毫秒.注意参数不能为负数,否则 ...
随机推荐
- SpringBootTest单元测试及日志
springboot系列学习笔记全部文章请移步值博主专栏**: spring boot 2.X/spring cloud Greenwich. 由于是一系列文章,所以后面的文章可能会使用到前面文章的项 ...
- OtterTune源码解析
为了方便后面对ottertune进行魔(hu)改(gao),需要先搞清楚它的源码结构和pipeline OtterTune分为两大部分: server side: 包括一个MySQL数据库(用于存储调 ...
- 第一个progressive web application,发车!
progressive web application是谷歌推出的一种渐进式web应用,通过利用service-worker等来达到类似于原生应用,而且在chrome浏览器还可以添加到主页,完全就和一 ...
- 关于conda-新手必读
一.管理conda 通过anaconda来安装python及python包,让你不必关心系统是否安装了一些依赖,如zlib等等,anaconda已经集成了这些依赖,可以方便的安装python 下载请点 ...
- AD转换为KiCAD的方法
一.Altium文件转KiCad文件 本文主要介绍: 1.AD文件(SCH和PCB)转换为KiCAD的方法 2.AD封装库转换为KiCAD库的方法 下面让我们进入正题 1.1 PCB的第一种转换方式 ...
- 基于celery的任务管理
1.celery基本原理 Celery是一个由python编写的简单.灵活.可靠的用来处理大量信息的分布式系统,同时提供了操作和维护分布式系统所需要的工具,说白了就是一个用来管理分布式队列的工具. C ...
- 2018-08-01-weekly
Algorithm 4. Median of Two Sorted Arrays What 两个排序数组的中位数 How 两个数组合并到同一个数组,然后进行排序取中间值即可 Key Codes cla ...
- thinkphp不读取.env文件的键对值
第一:$_ENV会为空,其原因通常是php的配置文件php.ini的配置项为: :variables_order :Default Value: “EGPCS” :Development Value: ...
- centos6.5安装nginx1.16.0
参考: centos7 编译安装nginx1.16.0( 完整版 ) https://blog.csdn.net/weixin_37773766/article/details/80290939 ...
- ClickOnce是什么?如何使用?
ClickOnce是一种部署方式,主要解决C/S软件版本更新后,所有客户端都要重新安装的问题. 场景:假如,你的客户有1000个,你的服务端更新后,这1000个客户都要重新安装,难道要员工一个一个的电 ...