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 {@Overridepublic 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 {@Overridepublic 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() {@Overridepublic void run() {ExampleService.test();}}, "Thread-A").start();new Thread(new Runnable() {@Overridepublic 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() {@Overridepublic void run() {testService.test();}}, "Thread-A").start();new Thread(new Runnable() {@Overridepublic 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 {@Overridepublic 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 {@Overridepublic 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 {@Overridepublic 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());}}@Overridepublic 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;}@Overridepublic 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;}@Overridepublic 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;}@Overridepublic 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;}@Overridepublic 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;}@Overridepublic 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 {@Overridepublic 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 {@Overridepublic 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方法也一直在运行状态，没有结束。

Java高并发编程：线程锁技术相关推荐

Java高并发编程详解系列-Java线程入门
根据自己学的知识加上从各个网站上收集的资料分享一下关于java高并发编程的知识点.对于代码示例会以Maven工程的形式分享到个人的GitHub上面. 首先介绍一下这个系列的东西是什么,这个系列自己 ...
高并发编程-线程通信_使用wait和notify进行线程间的通信2_多生产者多消费者导致程序假死原因分析
文章目录概述 jstack或者可视化工具检测是否死锁(没有) 原因分析概述高并发编程-线程通信_使用wait和notify进行线程间的通信 - 遗留问题我们看到了应用卡住了 .... 怀疑是 ...
Java高并发入门-线程初步
Java高并发入门-线程初步线程与进程之间的关系进程就是我们运行在计算机上的一个程序,对应Java程序来说就是运行在计算机上的Java应用程序,这个程序在运行的时候就会创建了一个进程,服务器上就会 ...
Java高并发编程（马士兵老师视频）笔记（一）同步器
本篇主要总结同步器的相关例子:包括synchronized.volatile.原子变量类(AtomicXxx).CountDownLatch.ReentrantLock和ThreadLocal.还涉及 ...
Java高并发编程学习（三）java.util.concurrent包
简介我们已经学习了形成Java并发程序设计基础的底层构建块,但对于实际编程来说,应该尽可能远离底层结构.使用由并发处理的专业人士实现的较高层次的结构要方便得多.要安全得多.例如,对于许多线程问题,可 ...
@冰河老师的巨作，人手一册的Java高并发编程指南，值得了解一下
还真不好意思,这次 Java Thread Pool 惊爆了! 高并发是每一个后端开发工程师都头疼的问题,也是工程师能力的分水岭.要想基于JDK核心技术,玩转高并发编程,必须要好好修炼内功才行. 文章 ...
29W 字总结阿里 Java 高并发编程：案例 + 源码 + 面试 + 系统架构设计
下半年的跳槽季已经开始,好多同学已经拿到了不错的 Offer,同时还有一些同学对于 Java 高并发编程还缺少一些深入的理解,不过不用慌,今天老师分享的这份 27W 字的阿里巴巴 Java 高并发编程 ...
Java高并发编程：线程池
这里首先介绍了java5中的并发的小工具包:java.util.concurrent.atomic,然后介绍了线程池的概念,对使用java5的方式创建不同形式的线程进行了演示,之后介绍了两个对象:C ...
Java高并发编程：活跃性危险
Java高并发程序中,不得不出现资源竞争以及一些其他严重的问题,比如死锁.线程饥饿.响应性问题和活锁问题.在安全性与活跃性之间通常存在依赖,我们使用加锁机制来确保线程安全,但是如果过度地使用加锁,则可 ...

Java高并发编程：线程锁技术

目录