介紹
程序(program)是為完成特定任務、用某種語言編寫的一組指令的集合。即指一段靜態的代碼，靜態對象。
進程(process)是程序的一次執行過程，或是正在運行的一個程序。是一個動態的過程:有它自身的產生、存在和消亡的過程。——生命周期
>如:運行中的QQ，運行中的MP3播放器
>程序是靜態的，進程是動態的
>進程作為資源分配的單位，系統在運行時會為每個進程分配不同的內存區域
線程(thread)，進程可進一步細化為線程，是一個程序內部的一條執行路徑。若一個進程同一時間並行執行多個線程，就是支持多線程的線程作為調度和執行的單位，每個線程擁有獨立的運行棧和程序計數器(pc)，線程切換的開銷小；
一個進程中的多個線程共享相同的內存單元/內存地址空間→它們從同一堆中分配對象，可以訪問相同的變量和對象。這就使得線程間通信更簡便、高效。但多個線程操作共享的系統資源可能就會帶來安全的隱患。
為什么需要多線程
眾所周知，CPU、內存、I/O 設備的速度是有極大差異的，為了合理利用 CPU 的高性能，平衡這三者的速度差異，計算機體系結構、操作系統、編譯程序都做出了貢獻。
線程狀態轉換
新建(New)
創建后尚未啟動。
就緒(Runnable)
可能正在運行，也可能正在等待 CPU 時間片。
包含了操作系統線程狀態中的 Running 和 Ready。
阻塞(Blocking)
等待獲取一個排它鎖，如果其線程釋放了鎖就會結束此狀態。
無限期等待(Waiting)
等待其它線程顯式地喚醒，否則不會被分配 CPU 時間片。
限期等待(Timed Waiting)
無需等待其它線程顯式地喚醒，在一定時間之后會被系統自動喚醒。
調用 Thread.sleep() 方法使線程進入限期等待狀態時，常常用“使一個線程睡眠”進行描述。
調用 Object.wait() 方法使線程進入限期等待或者無限期等待時，常常用“掛起一個線程”進行描述。
睡眠和掛起是用來描述行為，而阻塞和等待用來描述狀態。
阻塞和等待的區別在於，阻塞是被動的，它是在等待獲取一個排它鎖。而等待是主動的，通過調用 Thread.sleep() 和 Object.wait() 等方法進入。
死亡(Terminated)
可以是線程結束任務之后自己結束，或者產生了異常而結束。
線程使用方式
有三種使用線程的方法:
- 實現 Runnable 接口；
- 實現 Callable 接口；
- 繼承 Thread 類。
實現 Runnable 和 Callable 接口的類只能當做一個可以在線程中運行的任務，不是真正意義上的線程，因此最后還需要通過 Thread 來調用。可以說任務是通過線程驅動從而執行的。
繼承 Thread 類
public class ThreadTest {
/**
* 多線程的創建，
* 方式一：
* 1.繼承與Thread類
* 2.重寫Thread類的run方法->將此線程執行的操作聲明在run中
* 3.創建Thread類的子類
* 4.通過此對象調用start
*/
public static void main(String[] args) {
// 創建Thread類的子類的對象
MyThread t1 = new MyThread();
//不能通過run方法開啟線程，因為還會在主線程中運行，應該使用start方法開啟線程
//不能通過調用兩次start方法來開啟兩個子線程
t1.start();
//可以通過再創建一個對象來實現
for (int i=0;i<1000;i++){
if (i%2!=0){
System.out.println(i+"****");
}
}
}
}
class MyThread extends Thread{
@Override
public void run() {
for (int i=0;i<1000;i++){
if (i%2==0){
System.out.println(i);
}
}
}
}
/**
* 方式二：
* 匿名子類創建，針對只調用一次的線程
*/
public static void main(String[] args) {
MyThread1 myThread1 = new MyThread1();
myThread1.start();
MyThread2 myThread2 = new MyThread2();
myThread2.start();
//通過匿名子類實現調用：特點只需要調用一次的子線程
new Thread(){
@Override
public void run() {
for (int i=0;i<1000;i++){
if (i%3==0){
System.out.println(Thread.currentThread().getName()+"***"+i);
}
}
}
}.start();
}
}
class MyThread1 extends Thread{
@Override
public void run() {
for (int i=0;i<100;i++){
if (i%2!=0){
System.out.println(Thread.currentThread().getName()+"***"+i);
}
}
}
}
class MyThread2 extends Thread{
@Override
public void run() {
for (int i=0;i<100;i++){
if (i%2==0){
System.out.println(Thread.currentThread().getName()+"***"+i);
}
}
}
}
實現 Runnable 接口
package com.atguigu.juc.runnable;
/**
* 創建多線程方式Runnable
* 1.創建一個實現Runnable接口的類
*
* 2.實現類去實現Runnable中的抽象方法: run( )
*
* 3.創建實現類的對象
*
* 4、將此對象作為參數傳遞到Thread類的構造器中，創建Thread類的對象
*
* 5，通過Thread類的對象調用start()
*/
public class TestThread {
public static void main(String[] args) {
//3.創建實現類的對象
MyThread myThread = new MyThread();
//4、將此對象作為參數傳遞到Thread類的構造器中，創建Thread類的對象
Thread t1 = new Thread(myThread);
//5，通過Thread類的對象調用start()
t1.start();
}
}
//1.創建一個實現Runnable接口的類
class MyThread implements Runnable{
//2.實現類去實現Runnable中的抽象方法: run( )
@Override
public void run() {
for (int i=0;i<100;i++){
if (i%2==0){
System.out.println(i);
}
}
}
}
實現 Callable 接口
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
/**
* 創建線程方式三：實現Callable接口
*如何理解實現Callable接口的方式創建多線程比實現Runnable接口創建多線程方式強大?
* 1. calL()可以有返回值的。
* 2. call可以拋出異常，被外面的操作捕獲，獲取異常的信總3. callable是支持泛型的
*
*/
public class ThreadNew {
public static void main(String[] args) {
// 3.創建Callable接口實現類的對象
NumberThread numberThread = new NumberThread();
//4.將此callable接口實現類的對象作為傳遞到FutureTask構造器中，創建FutureTask的對象
FutureTask<Integer> futureTask = new FutureTask<>(numberThread);
//5.將FutureTask的對象作為參數傳遞到Thread類的構造器中，創建Thread對象，並調用start()
new Thread(futureTask).start();
try {
//6.獲取線程返回值
//get()返回值即為FutureTask構造器參數callable實現類重寫的calL()的返回值。
Integer sum = futureTask.get();
System.out.println(sum);
} catch (Exception e) {
e.printStackTrace();
}
}
}
//1.創建一個實現CaLlabLe的實現類
class NumberThread implements Callable<Integer>
{
//2.實現caLl方法，將此線程需要執行的操作聲明在call()中
@Override
public Integer call() throws Exception {
int sum=0;
for(int i=0;i<=100;i++){
if (i%2==0){
System.out.println(Thread.currentThread().getName()+":::"+i);
sum+=i;
}
}
return sum;
}
}
線程池
package com.atguigu.juc.pool;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
/**
*好處:
* 1.提高響應速度（減少了創建新線程的時間)
* 2.降低資源消耗（重復利用線程池中線程，不需要每次都創建)3.便於線程管理
* corePoolsize:核心池的大小maximumPoolsize:最大線程數
* keepALiveTime:線程沒有任務時最多保持多長時間后會終止
*/
public class ThreadPool {
public static void main(String[] args) {
//1．提供指定線程數量的線程池
ExecutorService pool = Executors.newFixedThreadPool(10);
// ThreadPoolExecutor service1= (ThreadPoolExecutor) pool;
// service1.setCorePoolSize(15);
System.out.println(pool.getClass());
//2.執行指定的線程的操作。需要提供實現Runnable接口或Callable接口實現類的對象
pool.execute(new NumberThread());//適合適用於Runnable
pool.execute(new NumberThread1());
//pool.submit();//適合使用於calLable
//3.關閉連接池
pool.shutdown();
}
}
class NumberThread implements Runnable{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i%2==0){
System.out.println(Thread.currentThread().getName()+"::"+i);
}
}
}
}
class NumberThread1 implements Runnable{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i%2==0){
System.out.println(Thread.currentThread().getName()+"::"+i);
}
}
}
}
線程常見方法
package com.atguigu.juc.tset01;
/**
* 1.yield():釋放當前cpu的執行權
*
* 2.start():啟動當前線程;調用當前線程的run()
*
* 3.run():通常需要重寫Thread類中的此方法，將創建的線程要執行的操作聲明在此方法中
*
* 4.getName()∶獲取當前線程的名字
*
* 5.setName():設置當前線程的名字
*
* 6.currentThread():靜態方法，返回執行當前代碼的線程
*
* 7.join():在線程a中調用線程b的join(),此時線程a就進入阻塞狀態，直到線程b完全執行完以后，線程a才結束阻塞狀態。
*
* 8.sleep():讓當前線程"睡眠”指定的毫秒。在指定的毫秒時間內，當前線程是阻塞狀態。
*
*/
public class MyThreatTest {
public static void main(String[] args) {
TestMyThread t1 = new TestMyThread();
t1.start();
new Thread(){
@Override
public void run(){
for (int i=0;i<100;i++){
if (i%2==0){
try {
sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "子線程" + i);
yield();
}
}
}
}.start();
for (int i=0;i<100;i++){
if (i%3==0){
System.out.println(Thread.currentThread().getName() + "main方法" + i);
}
if (i==20){
try {
t1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
class TestMyThread extends Thread{
@Override
public void run(){
for (int i=0;i<100;i++){
if (i%5==0){
System.out.println(Thread.currentThread().getName() + "2222222222222子線程" + i);
}
}
}
}
synchronized鎖機制
- 一把鎖只能同時被一個線程獲取，沒有獲得鎖的線程只能等待；
- 每個實例都對應有自己的一把鎖(this),不同實例之間互不影響；例外：鎖對象是*.class以及synchronized修飾的是static方法的時候，所有對象公用同一把鎖
- synchronized修飾的方法，無論方法正常執行完畢還是拋出異常，都會釋放鎖
同步代碼---Runnable接口方式
/**
*方式一:同步代碼塊
* synchronized(同步監視器){
* //需要被同步的代碼
* }
* 說明:
* 1.操作共享數據的代碼，即為需要被同步的代碼
* 2.共享數據:多個線程共同操作的變量
* 3.同步監視器，俗稱:鎖。任何一個類的對象都可以作為索
* 4.在Java中，我們通過同步機制，來解決線程的安全問題。
* 補充:在實現Runnable接口創建多線程的方式中，我們可以考慮使用this充當同步監視器。
* 方式二:同步方法
* 如果操作共享數據的代碼完整的聲明在一個方法中，我們不妨將此方法聲明同步的。
* 5.同步的方式，解決了線程的安全問題。---好處
* 操作同步代碼時，只能有一個線程參與，其他線程等待。相當於是一個單線程的過程，效率低。
*/
public class WindowToRunnable {
public static void main(String[] args) {
Window2 window2 = new Window2();
Thread t1 = new Thread(window2);
Thread t2 = new Thread(window2);
Thread t3 = new Thread(window2);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
class Window2 implements Runnable{
//這里不用加static,因為調用的對象只有一個
private int ticket=100;
@Override
public void run() {
while (true) {
synchronized (this.getClass()){
if (ticket > 0) {
// try {
// Thread.sleep(100);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
System.out.println(Thread.currentThread().getName() + "買票,票號:" + ticket);
ticket--;
}
}
}
}
}
同步方法--Runnable接口方法
package com.atguigu.juc.bookPage;
/**
* 使用同步方法解決實現Runnable接口的線程安全問題
* 關於同步方法的總結:
* 1.同步方法仍然涉及到同步監視器，只是不需要我們顯式的聲明。
* 2．非靜態的同步方法，同步監視器是: this
* 靜態的同步方法，同步監視器是:當前類本身
*/
public class WindowExtSynn {
public static void main(String[] args) {
Window4 w1 = new Window4();
Window4 w2 = new Window4();
Window4 w3 = new Window4();
w1.setName("窗口1");
w2.setName("窗口2");
w3.setName("窗口3");
w1.start();
w2.start();
w3.start();
}
}
class Window4 extends Thread{
private static int ticket=100;
@Override
public void run() {
while (true){
show();
}
}
private static synchronized void show() {
if (ticket>0){
System.out.println(Thread.currentThread().getName()+":買票：票號為"+ticket);
ticket--;
}
}
}
同步方法---繼承方法
package com.atguigu.juc.bookPage;
/**
* 使用同步方法解決實現Runnable接口的線程安全問題
* 關於同步方法的總結:
* 1.同步方法仍然涉及到同步監視器，只是不需要我們顯式的聲明。
* 2．非靜態的同步方法，同步監視器是: this
* 靜態的同步方法，同步監視器是:當前類本身
*/
public class WindowExtSynn {
public static void main(String[] args) {
Window4 w1 = new Window4();
Window4 w2 = new Window4();
Window4 w3 = new Window4();
w1.setName("窗口1");
w2.setName("窗口2");
w3.setName("窗口3");
w1.start();
w2.start();
w3.start();
}
}
class Window4 extends Thread{
private static int ticket=100;
@Override
public void run() {
while (true){
show();
}
}
private static synchronized void show() {
if (ticket>0){
System.out.println(Thread.currentThread().getName()+":買票：票號為"+ticket);
ticket--;
}
}
}
死鎖
示例：兩個線程都拿到第一層鎖的key，然后都需要第二層鎖的key，但key在對方手中，而方法沒有執行完，都不可能釋放key，互相僵持。
import static java.lang.Thread.sleep;
public class TestSyn {
public static void main(String[] args) {
StringBuffer s1 = new StringBuffer();
StringBuffer s2 = new StringBuffer();
new Thread(){
@Override
public void run() {
synchronized (s1) {
s1.append("a");
s2.append("1");
try {
sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s2) {
s1.append("b");
s2.append("2");
System.out.println(s1);
System.out.println(s2);
}
}
}
}.start();
new Thread(new Runnable() {
@Override
public void run() {
synchronized (s2) {
s1.append("c");
s2.append("3");
try {
sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s1) {
s1.append("d");
s2.append("4");
System.out.println(s1);
System.out.println(s2);
}
}
}
}).start();
}
}
Lock鎖機制
import java.util.concurrent.locks.ReentrantLock;
/**
* 解決線程安全問題的方式三: Lock鎖--- JDK5.0新增
*
* synchronized 與Lock的異同?
* 相同:二者都可以解決線程安全問題
* 不同: synchronized機制在執行完相應的同步代碼以后，自動的釋放同步監視器
* Lock需要手動的啟動同步(Lock() )，同時結束同步也需要手動的實現(unlock())
*
*/
public class LockTest {
public static void main(String[] args) {
Window6 window6 = new Window6();
Thread t1 = new Thread(window6);
Thread t2 = new Thread(window6);
Thread t3 = new Thread(window6);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
class Window6 implements Runnable{
private int ticker=100;
private ReentrantLock lock=new ReentrantLock();
@Override
public void run() {
while (true){
lock.lock();
try {
if (ticker>0){
System.out.println(Thread.currentThread().getName()+"買票：票號："+ticker);
ticker--;
}else {
break;
}
} finally {
lock.unlock();
}
}
}
}
銀行有一個賬戶。有兩個儲戶分別向同一個賬戶存3000元，每次存1e00，存3次。每次存完打印賬戶余額。
/**
* 銀行有一個賬戶。
* 有兩個儲戶分別向同一個賬戶存3000元，每次存1e00，存3次。每次存完打印賬戶余額。
* 分析:
* 1.是否是多線程問題?是，兩個儲戶線程
* 2.是否有共享數據?有，賬戶（或賬戶余額).
* 3.是否有線程安全問題?有
* 4.需要考慮如何解決線程安全問題?同步機制:有三種方式。
*/
public class AccountTest {
public static void main(String[] args) {
Account account = new Account(0);
Customer c1 = new Customer(account);
Customer c2 = new Customer(account);
c1.setName("A");
c2.setName("B");
c1.start();
c2.start();
}
}
class Account{
private double balance;
public Account(double balance) {
this.balance = balance;
}
//存錢
public synchronized void deposit(double amt){
//synchronized (this.getClass()) {
if (amt>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
balance+=amt;
System.out.println(Thread.currentThread().getName()+"存錢成功，余額為"+balance);
}
// }
}
}
class Customer extends Thread{
private Account acc;
public Customer(Account acc){
this.acc=acc;
}
@Override
public void run() {
for (int i=0;i<30;i++){
acc.deposit(1000);
}
}
}
A存錢成功，余額為1000.0 B存錢成功，余額為2000.0 B存錢成功，余額為3000.0 B存錢成功，余額為4000.0 A存錢成功，余額為5000.0 A存錢成功，余額為6000.0
線程通信
多個線程在處理同一個資源，並且任務不同時，需要線程通信來幫助解決線程之間對同一個變量的使用或操作。
就是多個線程在操作同一份數據時， 避免對同一共享變量的爭奪。
於是我們引出了等待喚醒機制：（wait()、notify()）
就是在一個線程進行了規定操作后，就進入等待狀態（wait）， 等待其他線程執行完他們的指定代碼過后 再將其喚醒（notify）；
（1）wait()方法：
線程調用wait()方法，釋放它對鎖的擁有權，同時他會在等待的位置加一個標志，為了以后使用notify()或者notifyAll()方法 喚醒它時，它好能從當前位置獲得鎖的擁有權，變成就緒狀態，
要確保調用wait()方法的時候擁有鎖，即，wait()方法的調用必須放在synchronized方法或synchronized塊中。 在哪里等待被喚醒時，就在那里開始執行。
（2）notify/notifyAll()方法：
notif()方法：notify()方法會喚醒一個等待當前對象的鎖的線程。喚醒在此對象監視器上等待的單個線程。
notifAll()方法：notifyAll（）方法會喚醒在此對象監視器上等待的所有線程。
當執行notify/notifyAll方法時，會喚醒一個處於等待該 對象鎖 的線程，然后繼續往下執行，直到執行完退出對象鎖鎖住的區域（synchronized修飾的代碼塊）后再釋放鎖。
從這里可以看出，notify/notifyAll()執行后，並不立即釋放鎖，而是要等到執行完臨界區中代碼后，再釋放。故在實際編程中，我們應該盡量在線程調用notify/notifyAll()后，立即退出臨界區。即不要在notify/notifyAll()后面再寫一些耗時的代碼。
1.wait( )，notify( )，notifyAlL()三個方法必須使用在同步代碼塊或同步方法中。
2.wait()，notify( )，notifyAll()三個方法的調用者必須是同步代碼塊或同步方法中的同步監視器否則，會出現iLlegaLMonitorstateException異常
3.wait()，notify( )，notifyAlL()三個方法是定義在java.Lang.object類中。
sleep和wait異同
相同點：一但執行方法，都可以使得當前的線程進入阻塞狀態。
不同點：
1）兩個方法聲明的位置不同: Thread類中聲明sLeep() , object類中聲明wait()
2）調用的要求不同: sleep()可以在任何需要的場景下調用。wait()必須使用在同步代碼塊或同步方法
3）關於是否釋放同步監視器:如果兩個方法都使用在同步代碼塊或同步方法中，sLeep()不會釋放鎖，wait（）會釋放鎖。
package com.atguigu.juc.tongxin;
/**
* 線程通信的例子:使用兩個線程打印1-100。線程1，線程2交替打印
*/
public class CommunicationTest {
public static void main(String[] args) {
Number number = new Number();
Thread t1 = new Thread(number);
Thread t2 = new Thread(number);
Thread t3 = new Thread(number);
t1.setName("窗口1");
t2.setName("窗口2");
t1.start();
t2.start();
}
}
class Number implements Runnable{
private int number=1;
@Override
public void run() {
while (true){
synchronized (this) {
notify();
if (number <=100) {
System.out.println(Thread.currentThread().getName()+":::"+number);
number++;
try {
//使得調用如下wait方法的線程進入阻塞狀態
wait();
} catch (InterruptedException e) {
}
}else {
break;
}
}
}
}
}
生產者/消費者問題
/**
* 線程通信的應用:經典例題:生產者/消費者問題
* 生產者(Productor)將產品交給店員(Clerk)，而消費者(Customer)從店員處取走產品，
* 店員一次只能持有固定數量的產品(比如:20)，如果生產者試圖生產更多的產品，店員會叫生產者停一下，
* 如果店中有空位放產品了再通知生產者繼續生產，如果店中沒有產品了，店員會告訴消費者等一下，
* 如果店中有產品了再通知消費者來取走產品。
*
* 分析:
* 1．是否是多線程問題?是，生產者線程，消費者線程
* 2．是否有共享數據?是，店員或產品
* 3. 如何解決線程的安全問題?同步機制,有三種方法
* 4. 是否涉及線程的通信?是
*/
public class productTest {
public static void main(String[] args) {
Clerk clerk = new Clerk();
Producer p1 = new Producer(clerk);
Consumer c1 = new Consumer(clerk);
p1.setName("生產者1");
c1.setName("消費者1");
p1.start();
c1.start();
}
}
class Clerk{
private int produceProduct=0;
//生產產品
public synchronized void produceProduck() {
if (produceProduct<20){
produceProduct++;
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
notify();
System.out.println(Thread.currentThread().getName()+"開始生產第"+produceProduct+"個產品");
}else {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//消費產品
public synchronized void cunsumeProduck() {
if(produceProduct>0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"開始消費第"+produceProduct+"個產品");
produceProduct--;
notify();
}else {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Producer extends Thread{//生成者
private Clerk clerk;
public Producer(Clerk clerk){
this.clerk=clerk;
}
@Override
public void run() {
System.out.println(getName()+"開始生產產品....");
while (true){
try {
sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.produceProduck();
}
}
}
class Consumer extends Thread{//消費者
private Clerk clerk;
public Consumer(Clerk clerk){
this.clerk=clerk;
}
@Override
public void run() {
System.out.println(getName()+"開始消費產品....");
while (true){
try {
sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.cunsumeProduck();
}
}
}
防止多線程的虛假喚醒
多線程交互中判斷只用while，不能用if，if會造成多線程的虛假喚醒,若同時有多個線程在wait，突然被釋放，會立即同時被執行，可能導致數據錯誤，在if中的wait不會對wait中醒來的線程進行再次判斷，而while會再次判斷是否符合條件，只有條件符合才會釋放線程進行接下來操作。
package com.atguigu.sh.juc;
/*
題目:現在兩個線程，可以操作初始值為零的一個變量，實現一個線程對該變量加，一個線程對該變量減1，實現交替，來10輪，變量初始值為零。
1高聚低合前提下，線程操作資源類
2判斷/干活/通知
3.多線程交互中，必須要防止多線程的虛假喚醒，也即（判斷只用while，不能用if)
*/
public class ThreadWaitNotifyDemo {
public static void main(String[] args) {
AirCondition airCondition = new AirCondition();
new Thread(()->{
for (int i = 1; i <=10; i++) {
try {
airCondition.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"A").start();
new Thread(()->{
for (int i = 1; i <=10 ; i++) {
try {
airCondition.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"B").start();
new Thread(()->{
for (int i = 1; i <=10; i++) {
try {
airCondition.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"C").start();
new Thread(()->{
for (int i = 1; i <=10 ; i++) {
try {
airCondition.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"D").start();
}
}
class AirCondition{
private int number=0;
public synchronized void increment() throws InterruptedException {
if (number!=0){
this.wait();
}
number++;
System.out.println(Thread.currentThread().getName()+"\t"+number);
this.notifyAll();
}
public synchronized void decrement() throws InterruptedException {
if (number==0){
this.wait();
}
number--;
System.out.println(Thread.currentThread().getName()+"\t"+number);
this.notifyAll();
}
}
A 1 B 0 A 1 B 0 A 1 B 0 A 1 B 0 A 1 B 0 A 1 B 0 A 1 B 0 A 1 B 0 C 1 A 2 C 3 B 2 B 1 C 2 A 3 C 4 D 3 D 2 D 1 D 0 C 1 D 0 C 1 D 0 C 1 D 0 C 1 D 0 C 1 D 0 C 1 D 0