目录
1 什么是线程锁
实例的全局变量(共享资源)被修改时,会出现线程安全,需要对修改的方法加锁,注意:只要要访问多个线程共享的字段的方法都需要加锁保护。不能前门(方法A)锁上了,后门(方法B)就不锁了,或者窗户(方法C)开着了,这都不行,都必须锁住。
临界区:只允许单个线程执行的程序范围
多线程可以同时运行多个任务
但是当多个线程同时访问共享数据时,可能导致数据不同步,甚至错误!
so,不使用线程锁, 可能导致错误
线程锁技术:Lock & Condition 实现线程同步通信所属包:java.util.concurrent.locks
线程锁 | 说明 |
---|---|
Synchronized | 同步方法,锁对象是this;同步静态方法,锁对象是字节码.class;同步代码块,锁对象是任意对象,但必须是同一个对象 |
Lock | 同步锁接口 |
ReentrantLock | lock(),unlock(),newCondition() |
ReadWriteLock | 读写锁接口 |
ReentrantReadWriteLock | readLock()获取读锁,writeLock()获取写锁 |
Condition | 线程间通信 await()等待 signal()唤醒 |
synchronized和Lock锁的区别
1、synchronized是Java内置的关键字;Lock锁是Java的一个类
2、synchronized无法获取到锁的状态;Lock锁可以判断是否获取到了锁
3、synchronized会自动的释放锁;Lock必须要手动的去释放锁,如果不释放,就会造成死锁
4、synchronized中,线程一在获得锁的情况下阻塞了,第二个线程就只能傻傻的等着;Lock锁出现这种情况,可以使用tryLock()尝试获取锁
5、synchronized是不可中断的、非公平的、可重入锁;Lock锁是非公平的(可以自己设置)、可判断的、可重入锁
6、synchronized适合锁少量的同步代码;Lock锁适合锁大两的同步代码
7、synchronized有代码块锁和方法锁;Lock只有代码块锁
8、使用Lock锁,JVM将花费较少的时间来调度线程,性能更好。并且具有更好的扩展性(拥有更多的子类)
2 synchronized
synchronized是Java语言的关键字,当它用来修饰一个方法或者一个代码块的时候,能够保证在同一时刻最多只有一个线程执行该段代码,也就是保证synchronized内的代码块同步执行,而不会并行执行。
synchronized可以作为代码块使用,也可以直接放在方法(对象方法、静态方法)的签名上。作为代码块必须指定一个对象锁,对象锁就是一个对象,可以是this对象(即调用该方法的实例对象)也可以是自己创建的某个对象,也可以是某个类的字节码对象,synchronized修饰的代码属于原子操作,不可再分割!
-
作用实例方法时,锁住的是对象的实例(this)
-
作用静态方法时,锁住的是该类,该 Class所有实例,又因为 Class 的相关数据存储在永久带 PermGen(jdk1.8 则是 metaspace),永久带是全局共享的,因此静态方法锁相当于类的一个全局锁,会锁所有调用该方法的线程
- 线程A调用一个实例对象非静态Synchronized方法,允许线程B调用该实例对象所属类的静态s方法而不会发生互斥,前者锁的是当前实例对象,后者锁的是当前类
// 实例方法使用的是this锁,即调用该对象的实例
synchronized(this) {
// code
}
Object object = new Object();
synchronized(object) {
// code
}
// 静态方法是使用的类锁
synchronized(Xxx.class) {
// code
}
// 对象锁(修饰对象方法,锁为this,即调用该方法的实例对象)
public synchronized void foo() {
}
// 类锁(修饰静态方法,锁为这个类,不是某一个对象)
public synchronized static void bar() {
}
当多个线程过来同时执行,如何保证同一时刻只有一个线程在执行(即同步执行)?
synchronized无论作为代码块还是直接修饰方法都会指定一个锁,当一个线程要想执行线程体就必须拿到这个锁,只有拿到锁的线程才能执行,这样只有一个线程能拿到锁,其他线程就拿不到锁,这样其它线程就执行不了,就必须等待,当拿到锁的那个线程执行完就去释放这个锁,这样其它等待的线程就去抢这个锁,哪个线程抢到了锁就去执行,抢不到就继续下一轮的抢。锁分为对象锁和类锁。
在用synchronized关键字的时候,尽量缩小代码块的范围,能在代码段上加同步就不要再整个方法上加同步。减小锁的粒度,使代码更大程度的并发。
1. 对象锁
public class ThisLock {
public static void main(String[] args) {
MyRunnable runnable = new MyRunnable();
System.out.println("runnable=" + runnable);
new Thread(runnable, "Thread-A").start();
new Thread(runnable, "Thread-B").start();
}
}
class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t" + this);
synchronized (this) {
for(int i = 0; i < 5; i++) {
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\ti=" + i);
try { Thread.sleep(1000); } catch (InterruptedException e) { }
}
}
}
}
通过打印结果可以看到this锁就是当前的线程对象runnable,可以看到代码块外的代码是并发执行的,而代码块内部的代码是同步执行的,即同一时刻只有一个线程在执行同步代码块。Thread-A先拿到锁就先执行,直到执行完毕,释放锁,然后Thread-B拿到锁就执行。
示例代码中两个线程都是使用同一个runnable对象,如果两个线程各自使用各自的MyRunnable对象,则是并发的,不会是同步的。
// new Thread(runnable, "Thread-A").start();
// new Thread(runnable, "Thread-B").start();
// 锁无效,因为每个new就是一个新的对象,两个线程使用两个不同的锁,达不到互斥的效果
new Thread(new MyRunnable(), "Thread-A").start();
new Thread(new MyRunnable(), "Thread-B").start();
2. 修饰对象方法
public class MethodLock {
public static void main(String[] args) {
MyRunnable runnable = new MyRunnable();
System.out.println("runnable=" + runnable);
new Thread(runnable, "Thread-A").start();
new Thread(runnable, "Thread-B").start();
}
}
class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t" + this + "\trunning...");
myRun();
}
private synchronized void myRun() {
for(int i = 0; i < 4; i++) {
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\ti=" + i);
try { Thread.sleep(1000); } catch (InterruptedException e) { }
}
}
}
synchronized修饰方法,表示将会锁住整个方法体,锁的是当前对象,这个synchronized(this)代码块包括住方法的所有代码是一样的效果
// 两种方式效果一样
synchronized(this) {
for(int i = 0; i < 4; i++) {
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\ti=" + i);
try { Thread.sleep(1000); } catch (InterruptedException e) { }
}
}
private synchronized void myRun() {
for(int i = 0; i < 4; i++) {
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\ti=" + i);
try { Thread.sleep(1000); } catch (InterruptedException e) { }
}
}
3. 类锁
public class ClassLock {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
ExampleService.test();
}
}, "Thread-A").start();
new Thread(new Runnable() {
@Override
public void run() {
ExampleService.test2();
}
}, "Thread-B").start();
}
}
class ExampleService {
// 静态方法
public synchronized static void test() {
for(int i = 0; i < 4; i++) {
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\ti=" + i);
try { Thread.sleep(500); } catch (InterruptedException e) { }
}
}
// 静态方法
public synchronized static void test2() {
for(int i = 0; i < 4; i++) {
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\ti=" + i);
}
}
}
两个线程分别调用不同的静态方法,两个方法是同步执行,而不是并发执行。因为两个线程都是使用的类锁ExampleService.class, 当Thread-A执行时拿到了ExampleService的类锁,那么Thread-B就拿不到这个类锁了,只有Thread-A执行完毕后释放类锁,Thread-B才能拿到类锁继续执行,所以是同步执行的。
静态同步函数的锁是class对象
4. 对象锁和类锁
public class ObjectClassLock {
public static void main(String[] args) {
TestService testService = new TestService();
new Thread(new Runnable() {
@Override
public void run() {
testService.test();
}
}, "Thread-A").start();
new Thread(new Runnable() {
@Override
public void run() {
testService.test2();
}
}, "Thread-B").start();
}
}
class TestService {
// 锁的是testService这个对象
public synchronized void test() {
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t running...");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println((new Date() + "\t" + Thread.currentThread().getName() + "\t over"));
}
// 静态是锁的TestService这个类(TestService.class)
// 对象锁和类锁不是同一个锁,所以两个方法不会互斥
public synchronized static void test2() {
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t running...");
System.out.println((new Date() + "\t" + Thread.currentThread().getName() + "\t over"));
}
}
Thread-A是访问的对象方法,锁为当前调用者即锁对象为testService,Thread-B虽然是通过对象调用的但是是访问的类方法,锁为类锁,即TestService.class, 因两个线程使用的是不同的锁,自然就互不影响,各自执行各自的,所以是并发执行的,而不是同步执行的。
5. 卖火车票示例
public class TrainTicketTest {
int num = 2;
public static void main(String[] args) {
// 抢火车票功能
TrainTicketTest synchronizedTest = new TrainTicketTest();
for (int i = 0; i < 5; i ++) {
new Thread(synchronizedTest.new TrainTicketThread()).start();
}
}
class TrainTicketThread implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "\trunning");
// 模拟业务耗时的时间
try { Thread.sleep(500);} catch (InterruptedException e) { }
if (num > 0) {
System.out.println(Thread.currentThread().getName() + "\t抢到一张票\t目前还有" + num + "张\t");
int temp = num - 1;
num = temp;
System.out.println(Thread.currentThread().getName() + "还剩余" + num + "张");
}
}
}
}
因多线程可能每次运行效果都不同,这里给出一种效果,总共2张票,卖出去3张,卖超了
根据上面的运行结果试图对多线程代码执行分析
出现多卖的原因是由于多线程CPU时间片“随机”的切换,同一段代码被多个线程同时执行,导致值的错乱,解决这种问题的办法就是同一段代码同一时间不允许多个线程执行,也就是只能允许一个线程来执行。
我们可以为代码加上一个锁,哪个线程想要执行这段代码必须手里拿着锁才能执行,当执行完毕就把锁丢出去,其它线程如果想要执行就必须抢到锁(注意多个线程必须使用同一个锁),只有抢到锁了才能执行加锁的代码,为代码加锁有两种方式synchronized和lock,锁就是一个对象。
public class TrainTicketTest {
// 全局变量,必须保证所有线程都在使用同一个锁
Object object = new Object();
int num = 2;
public static void main(String[] args) {
// 抢火车票功能
TrainTicketTest synchronizedTest = new TrainTicketTest();
for (int i = 0; i < 5; i ++) {
new Thread(synchronizedTest.new TrainTicketThread()).start();
}
}
class TrainTicketThread implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "running");
try { Thread.sleep(500);} catch (InterruptedException e) { }
synchronized (object) {
if (num > 0) {
System.out.println(Thread.currentThread().getName() + "\t抢到一张票\t目前还有" + num + "张\t");
int temp = num - 1;
num = temp;
System.out.println(Thread.currentThread().getName() + "还剩余" + num + "张");
}
}
}
}
}
public class TrainTicket2Test {
int num = 2;
public static void main(String[] args) {
// 抢火车票功能
TrainTicket2Test synchronizedTest = new TrainTicket2Test();
for (int i = 0; i < 5; i ++) {
new Thread(synchronizedTest.new TrainTicketThread()).start();
}
}
class TrainTicketThread implements Runnable {
@Override
public void run() {
getTrainTicket();
}
}
private synchronized void getTrainTicket() {
System.out.println(Thread.currentThread().getName() + "running");
try { Thread.sleep(500);} catch (InterruptedException e) { }
if (num > 0) {
System.out.println(Thread.currentThread().getName() + "\t抢到一张票\t目前还有" + num + "张\t");
int temp = num - 1;
num = temp;
System.out.println(Thread.currentThread().getName() + "还剩余" + num + "张");
}
}
}
分别是
Thread-0running
Thread-1running
Thread-4running
Thread-3running
Thread-2running
Thread-0 抢到一张票 目前还有2张
Thread-0还剩余1张
Thread-1 抢到一张票 目前还有1张
Thread-1还剩余0张
Thread-0running
Thread-0 抢到一张票 目前还有2张
Thread-0还剩余1张
Thread-4running
Thread-4 抢到一张票 目前还有1张
Thread-4还剩余0张
Thread-3running
Thread-2running
Thread-1running
三个人在不停的过一个门,一个门一次只能通过一个,每通过一个人就记录通过的总人数及最后通过的人的姓名和地址。
Gate: 模拟门类
public class Gate {
private int counter = 0;
private String name = "Noboday";
private String address = "Nowhere";
public synchronized void pass(String name, String addrees) {
this.counter++;
this.name = name;
this.address = addrees;
check();
}
private void check() {
if (name.charAt(0) != address.charAt(0)) {
System.out.println("****BROKEN****" + toString());
}
}
@Override
public synchronized String toString() {
return "No." + counter + ":" + name + "," + address;
}
}
UserThread: 模拟人不停的过门
public class UserThread extends Thread {
private final Gate gate;
private final String myName;
private final String myAddress;
public UserThread(Gate gate, String myName, String myAddress){
this.gate = gate;
this.myName = myName;
this.myAddress = myAddress;
}
@Override
public void run() {
System.out.println(myName + "BEGIN");
while (true) {
gate.pass(myName, myAddress);
}
}
}
Main: 三个人不停的过门,为了便于区分,每个人的姓名和地址首字母是相同的
public class Main {
public static void main(String[] args) {
Gate gate = new Gate();
// 3个人过的是同一个门gate,即synchronized修饰方法=synchronized(this)=synchronized(gate)
// 3个人是使用的同一把gate锁
new UserThread(gate, "Alice", "Alaska").start();
new UserThread(gate, "Bobby", "Brazil").start();
new UserThread(gate, "Chris", "Canada").start();
}
}
去掉Gate类中的pass和toString方法的synchronized,运行效果如图
-
Alice, Canada: Thread-0先执行this.name = name, 此时name=Chris, 此时CPU切换到Thread-1,然后执行了this.name = name; this.address = address; 此时name=Alice, address= Alaska; 此时CPU切换到Thread-0的address赋值,此时address=Canada, 所以最终的name=Alice,address=Canada, 两个值状态不一致。
-
Bobby,Brazil: 假如Thread-0是Bobby,假如Thread-0先执行this.name = name; 此时name=bobby;此时CPU切换到Thread-1, 假如Thread-1是Chris,Thread分别执行了给name和address分别赋值,此时name=Chris,address=Canada, 然后CPU切回到Thread-0,执行this.address=address, 此时adress为Brazil, 接着Thread-0又执行完了check()方法,此时CPU又切到Thread-1执行,开始执行check()方法,但是这个方法并没有一下子执行完,而是执行到if(name.charAt(0) != address.charAt(0))这个判断的时候又切到Thread-0了,注意此时没有没有执行if体中的代码,只是仅仅执行了条件判断,此时还没有进入if体就被切走了,切到Thread-0执行this.name=name,此时name=Bobby,此时又被切到Thread-1,执行刚才的if体,一打印,结果name=Bobby,address=Brazil, 这种问题的出现就是if判断和if体分开执行了,当再次执行if体的时候结果字段的值改变了
为什么toString方法也加锁?
所有访问或者操作多线程共享的全局变量时都应该加锁。
6. 生产一个消费一个示例
生产一个就要消费一个,消费不完不能生产。此示例生产者和消费者线程使用的是同一个对象锁person
wait和notify通常操作的是锁对象
- wait的作用:暂停线程执行,将当前线程的状态置为阻塞状态,并释放锁
- notify的作用:随机将调用notify方法的对象所对应的线程的状态置为就绪状态
public class MQExample {
public static void main(String[] args) {
Person person = new Person();
new Thread(new Producer(person)).start();
new Thread(new Consumer(person)).start();
}
}
class Producer implements Runnable {
private Person person;
public Producer(Person person) {
this.person = person;
}
@Override
public void run() {
synchronized (person) {
int i = 0;
while (true) {
if (i % 2 == 0) {
person.setName("小红");
person.setGender("女");
} else {
person.setName("小明");
person.setGender("男");
}
System.out.println(new Date() + "\t生产者生产了一个对象【" + person.getName() + ", " + person.getGender() +"】");
i++;
// 当生产完一个要释放锁
try {
person.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("----------------------------------------------------------");
person.notify();
}
}
}
}
class Consumer implements Runnable {
private Person person;
public Consumer(Person person) {
this.person = person;
}
@Override
public void run() {
synchronized (person) {
while (true) {
System.out.println(new Date() + "\t消费者消费了一个对象《" + person.getName() + ", " + person.getGender() + "》");
person.notify();
try {
person.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
class Person {
private String name;
private String gender;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
}
循环执行以上
该代码比较绕,进行分析一下
- 首先启动Producer生产者线程,进入run()方法拿到person锁,执行第一次while循环,打印【小红, 女】,执行person.wait()暂停当前线程执行,释放person对象锁
- 因Producer生产者线程在执行person.wait()释放了锁,而且生产者线程还被阻塞了,此时CPU该执行消费者线程Consumer,消费者线程能拿到person对象锁,就可以进入同步代码块从而执行第一个循环打印《小红, 女》,接下来执行person.notify() 会唤醒生产者线程Producer,将生产者线程的状态从阻塞状态设置为就绪状态,再接下来执行消费者的person.wait(),这行代码让消费者线程暂停执行,同时释放person锁
- 消费者因执行person.wait()导致消费者线程释放了person对象锁而且使消费者暂停执行,从而CPU就有机会执行生产者线程了,生成者能拿到person对象锁,而且当前状态为就绪状态,就有资格进入运行状态,此时生产者线程会接着上次没有执行完的代码继续执行,所以就执行了打印“——-”,接着执行生产者线程中的person.notify();此行代码的作用是让消费者置为就绪状态,此时因为生产者还持有锁,虽然消费者线程置为就绪状态,因拿不到锁,所以不具备运行的条件。当执行完生产者的person.notify();这行代码时,此时第一轮循环就结束了,接着继续循环第二轮,就继续打印【小明, 男】,然后执行person.wait()暂停当前线程执行,释放person对象锁,就这样步骤2,步骤3 一下循环下去执行
注意:Object.wait()和Object.notify() 只能用在同步方法或者同步代码块中synchronized
3 Lock
Lock比传统线程模型中的synchronized方式更加面向对象,相对于synchronized 方法和语句它具有更广泛的锁定操作,此实现允许更灵活的结构,可以具有差别很大的属性,可以支持多个相关的 Condition 对象。
于现实生活中类似,锁本身也是一个对象。两个线程执行的代码片段要实现同步互斥的结果,它们必须用同一个Lock对象,锁是上在代表要操作的资源的类的内部方法中,而不是线程代码中。
Lock需要手动加锁,释放锁也需要手动释放,释放锁最好(必须)放到finally代码块中释放。
注意:同一个锁可以加锁多次(调用多次lock() ),相应的加N次锁也必须解N次锁(unlock()),一般情况下都是加一次锁和解一次锁
package java.util.concurrent.locks;
public interface Lock {
// 加锁
void lock();
void lockInterruptibly() throws InterruptedException;
boolean tryLock();
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
// 释放锁
void unlock();
Condition newCondition();
}
3.1 重入锁 ReentrantLock
package java.util.concurrent.locks;
public class ReentrantLock implements Lock, java.io.Serializable {
public boolean isLocked();
}
方法声明 | 功能描述 |
---|---|
lock() | 获取锁 |
tryLock() | 尝试获取锁 |
unock() | 释放锁 |
newCondition() | 获取锁的Condition |
常用形式如下
public class ReentrantLockTest {
public static void main(String[] args) {
Lock lock = new ReentrantLock();
Runnable runnable = () -> {
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\trunning...");
lock.lock();
try {
for(int i = 0; i < 4; i++) {
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\ti=" + i);
try { Thread.sleep(1000); } catch (InterruptedException e) { }
}
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
};
new Thread(runnable, "Thread-A").start();
new Thread(runnable, "Thread-B").start();
}
}
使用ReentrantLock和使用synchronized 代码块都能达到上锁的目的。先执行Thread-A线程,当指定到lock.lock()当前线程就拿到锁,然后执行线程体,最后执行lock.unlock()释放锁,这样Thread-B就能拿到线程继续执行。
3.2 读写锁
分为读锁和写锁,多个读锁不互斥,读锁与写锁互斥,写锁与写锁互斥,这是由JVM自己控制的。你只要上好相应的锁即可。如果你的代码只读数据,可以很多人同时读,但不能同时写,那就上读锁;如果你的代码修改数据,只能有一个人在写,且不能同时读取,那就上写锁。总之,读的时候上读锁,写的时候上写锁!
读写锁的使用情景:
- 如果代码只读数据,就可以很多人共同读取,但不能同时写。
- 如果代码修改数据,只能有一个人在写,且不能同时读数据。
public class ReadWriteLockTest {
private volatile static Map<String, Object> cacheMap = new HashMap<>();
private static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
static ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
static ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();
public static void main(String[] args) {
// 写的时候不能读,读的时候不能写,写的时候不能写,读的时候可以读
new Thread(() -> {
for(int i = 0;i < 5; i++) {
put(i + "", i);
}
}).start();
new Thread(() -> {
for(int i = 0; i < 5; i++) {
get(i + "");
}
}).start();
new Thread(() -> {
for(int i = 0;i < 5; i++) {
put(i + "", i);
}
}).start();
}
public static Object put(String key, Object value) {
try {
writeLock.lock();
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t写\t" + key + "=" + value + "\tstart...");
try { Thread.sleep(1000); } catch (InterruptedException e) { }
cacheMap.put(key, value);
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t写\t" + key + "=" + value + "\tend");
} catch (Exception e) {
} finally {
writeLock.unlock();
}
return value;
}
public static Object get(String key) {
try {
readLock.lock();
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t读\t" + key + "\tstart...");
try { Thread.sleep(1000); } catch (InterruptedException e) { }
Object value = cacheMap.get(key);
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t读\t" + key + "\tend");
return value;
} catch (Exception e) {
} finally {
readLock.unlock();
}
return null;
}
}
4 Condition
用于实现线程间的通信,是为了解决Object.wait()、nitify()、notifyAll()难以使用的问题
Condition 将 Object 监视器方法(wait、notify 和 notifyAll)分解成截然不同的对象,以便通过将这些对象与任意 Lock 实现组合使用,为每个对象提供多个等待 set(wait-set)。其中,Lock 替代了 synchronized 方法和语句的使用,Condition 替代了 Object 监视器方法wait和notify的使用
一个锁内部可以有多个Condition,即有多路等待通知,传统的线程机制中一个监视器对象上只能有一路等待和通知,要想实现多路等待和通知,必须嵌套使用多个同步监视器对象。使用一个监视器往往会产生顾此失彼的情况。
在等待 Condition 时,允许发生“虚假唤醒”,这通常作为对基础平台语义的让步。对于大多数应用程序,这带来的实际影响很小,因为 Condition 应该总是在一个循环中被等待,并测试正被等待的状态声明。某个实现可以随意移除可能的虚假唤醒,但建议应用程序程序员总是假定这些虚假唤醒可能发生,因此总是在一个循环中等待。
方法声明 | 功能描述 |
---|---|
await() | 线程等待 |
await(long time, TimeUnit unit) | 线程等待特定的时间,超过等待时间则为超时 |
signal() | 随机唤醒某个等待线程 |
signalAll() | 唤醒所有等待中的线程 |
示例1
Object.wait和notify只能用于synchronized,如果想使用Lock就需要使用Condition来代替
public interface Condition {
// 等待,相当于Object.wait()
void await() throws InterruptedException;
long awaitNanos(long nanosTimeout) throws InterruptedException;
boolean await(long time, TimeUnit unit) throws InterruptedException;
// 唤醒,相当于Object.notify()
void signal();
void signalAll();
}
ConditionTest
public class ConditionTest {
public static void main(String[] args) throws InterruptedException {
// 多个线程必须使用相同的锁和条件
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
System.out.println(condition);
new Thread(new MyRunnable(lock, condition), "Thread-A").start();
Thread.sleep(1000);
new Thread(new MyRunnable2(lock, condition), "Thread-B").start();
}
}
class MyRunnable implements Runnable {
private Lock lock;
private Condition condition;
public MyRunnable(Lock lock, Condition condition) {
this.lock = lock;
this.condition = condition;
}
@Override
public void run() {
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t开始等待>>>");
lock.lock();
try {
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t已 苏 醒^_^");
}
}
class MyRunnable2 implements Runnable {
private Lock lock;
private Condition condition;
public MyRunnable2(Lock lock, Condition condition) {
this.lock = lock;
this.condition = condition;
}
@Override
public void run() {
lock.lock();
try {
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t开始通知...");
condition.signal();
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t通知完成。。。");
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
示例2
一共有3个线程,两个子线程先后循环2次,接着主线程循环3次,接着又回到两 个子线程先后循环2次,再回到主线程又循环3次,如此循环5次。
思路:老二先执行,执行完唤醒老三,老三执行完唤醒老大,老大执行完唤醒老二,以此循环,所以定义3个Condition对象和一个执行标识即可
示例出现的问题:两个文件中有同名类的情况
解决方案:可以将一个文件中的那个同名外部类放进类中,但是静态不能创建内部类的实例对象,所以需要加上static,这样两个类的名称就不一样了。 一个是原来的类名,一个是在自己类名前面加上外部类的类名。
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ThreeConditionCommunication {
public static void main(String[] args){
final Business business = new Business();
//创建并启动子线程老二
new Thread(new Runnable(){
@Override
public void run() {
for(int i=1;i<=5;i++){
business.sub2(i);
}
}
}).start();
//创建并启动子线程老三
new Thread(new Runnable(){
@Override
public void run() {
for(int i=1;i<=5;i++){
business.sub3(i);
}
}
}).start();
//主线程
for(int i=1;i<=5;i++){
business.main(i);
}
}
static class Business{
Lock lock = new ReentrantLock();
Condition condition1 = lock.newCondition();
Condition condition2 = lock.newCondition();
Condition condition3 = lock.newCondition();
//定义一个变量来决定线程的执行权
private int ShouldSub = 1;
public void sub2(int i){
//上锁,不让其他线程执行
lock.lock();
try{
if(ShouldSub != 2){ //如果不该老二执行,就等待
try {
condition2.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for(int j=1;j<=2;j++){
System.out.println("sub thread sequence of"+i+",loop of "+j);
}
ShouldSub = 3; //准备让老三执行
condition3.signal(); //唤醒老三
}finally{
lock.unlock();
}
}
public void sub3(int i){
lock.lock();
try{
if(ShouldSub != 3){
try {
condition3.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for(int j=1;j<=2;j++){
System.out.println("sub2 thread sequence of"+i+",loop of "+j);
}
ShouldSub = 1; //准备让老大执行
condition1.signal(); //唤醒老大
}finally{
lock.unlock();
}
}
//主线程
public void main(int i){
lock.lock();
try{
if(ShouldSub!=1){
try {
condition1.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for(int j=1;j<=3;j++){
System.out.println("main thread sequence of"+i+", loop of "+j);
}
ShouldSub = 2; //准备让老二执行
condition2.signal(); //唤醒老二
}finally{
lock.unlock();
}
}
}
}
main thread sequence of1, loop of 1
main thread sequence of1, loop of 2
main thread sequence of1, loop of 3
sub thread sequence of1,loop of 1
sub thread sequence of1,loop of 2
sub2 thread sequence of1,loop of 1
sub2 thread sequence of1,loop of 2
main thread sequence of2, loop of 1
main thread sequence of2, loop of 2
main thread sequence of2, loop of 3
sub thread sequence of2,loop of 1
sub thread sequence of2,loop of 2
sub2 thread sequence of2,loop of 1
sub2 thread sequence of2,loop of 2
main thread sequence of3, loop of 1
main thread sequence of3, loop of 2
main thread sequence of3, loop of 3
sub thread sequence of3,loop of 1
sub thread sequence of3,loop of 2
sub2 thread sequence of3,loop of 1
sub2 thread sequence of3,loop of 2
main thread sequence of4, loop of 1
main thread sequence of4, loop of 2
main thread sequence of4, loop of 3
sub thread sequence of4,loop of 1
sub thread sequence of4,loop of 2
sub2 thread sequence of4,loop of 1
sub2 thread sequence of4,loop of 2
main thread sequence of5, loop of 1
main thread sequence of5, loop of 2
main thread sequence of5, loop of 3
sub thread sequence of5,loop of 1
sub thread sequence of5,loop of 2
sub2 thread sequence of5,loop of 1
sub2 thread sequence of5,loop of 2
5 死锁
一个线程中有多个锁,多个线程同时执行,可能线程1获得A锁,线程2获得了B锁,然后线程A想得到B锁就一直等待有人释放,线程2想得到Asuo就等待两个人一直等待,两个线程各自持有一个,而且只有某个线程同时拥有AB锁才能执行,两个人都只得到一个,却谁都不愿意释放,导致两个线程都在等待。
就像一个门同时需要两把钥匙同时打开,张三拿一把,李四拿一把,他们两个谁都不把自己的那把给对方,张三说“李四你先把你的那把给我,我用户就还你”,李四说“张三你先把你的那把给我,我用户就还你”,两个人都比较固执,结果两个人一直僵持着
public class DeadLockTest {
public static String a = "a";
public static String b = "b";
public static void main(String[] args) {
new Thread(new MyTask0()).start();
new Thread(new MyTask1()).start();
}
}
class MyTask0 implements Runnable {
@Override
public void run() {
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t running...");
synchronized (DeadLockTest.a) {
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t first synchronized ...");
try { Thread.sleep(1000); } catch (InterruptedException e) { }
synchronized (DeadLockTest.b) {
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t second synchronized ...");
}
}
}
}
class MyTask1 implements Runnable {
@Override
public void run() {
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t running...");
synchronized (DeadLockTest.b) {
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t first synchronized ...");
try { Thread.sleep(1000); } catch (InterruptedException e) { }
synchronized (DeadLockTest.a) {
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t second synchronized...");
}
}
}
}
两个线程的第二个代码块都没有执行,main方法也一直在运行状态,没有结束。