文章目錄
- Java多線程
-
- 1 基本概念
-
- 1.1 線程與程序
- 1.2 線程排程
- 1.3 同步與異步
- 1.4 并發與并行
- 2 線程建立
-
- 2.1 方式一：繼承Thread類
- 2.2 方式二：實作Runnable接口建立線程
- 2.3 方式三：實作Callable接口建立線程
- 2.4 Lambda表達式
- 3 多線程使用
-
- 3.1 Thread常用方法
- 3.2 優先級
- 3.3 守護線程
- 3.4 線程安全
-
- 3.4.1 問題
- 3.4.2 同步代碼塊
- 3.4.3 同步方法
- 3.4.4 顯式鎖Lock類
- 3.5 公平鎖
- 3.6 死鎖
- 4 多線程狀态
-
- 4.1 概述
- 4.2 線程通信
-
- 4.3 生産者消費者問題
- 5 線程池Executors
-
- 5.1 概述
- 5.2 緩存線程池
- 5.3 定長線程池
- 5.4 單線程線程池
-
- 5.5 周期任務定長線程池
Java多線程
也是稍微整理了一下多線程基礎的東西吧，再回顧一遍。
1 基本概念
1.1 線程與程序
程序
- 是指一個記憶體中運作的應用程式，每個程序都有一個獨立的記憶體空間
線程
- 是程序中的一個執行路徑，共享一個記憶體空間，線程之間可以自由切換，并發執行. 一個程序最少有一個線程
- 線程實際上是在程序基礎之上的進一步劃分，一個程序啟動之後，裡面的若幹執行路徑又可以劃分成若幹個線程
1.2 線程排程
分時排程
- 所有線程輪流使用 CPU 的使用權，平均配置設定每個線程占用 CPU 的時間。
搶占式排程
- 優先讓優先級高的線程使用 CPU，如果線程的優先級相同，那麼會随機選擇一個(線程随機性)，Java使用的為搶占式排程。
- CPU使用搶占式排程模式在多個線程間進行着高速的切換。對于CPU的一個核新而言，某個時刻，隻能執行一個線程，而 CPU的在多個線程間切換速度相對我們的感覺要快，看上去就是 在同一時刻運作。 其實，多線程程式并不能提高程式的運作速度，但能夠提高程式運作效率，讓CPU的 使用率更高。
1.3 同步與異步
同步:排隊執行 , 效率低但是安全.
異步:同時執行 , 效率高但是資料不安全.
1.4 并發與并行
并發：指兩個或多個事件在同一個時間段内發生。比如說1秒鐘内有多少個人點選了這個按鈕，這就是并發。
并行：指兩個或多個事件在同一時刻發生（同時發生），比如現在有多少個使用者線上，我左手畫圓的同時右手畫矩形等等。
2 線程建立
Java使用Thread類代表線程，所有的線程對象都必須是Thread類或其子類的執行個體。Java可以用四種方式來建立線程，如下所示：
1）繼承Thread類建立線程（重點）
2）實作Runnable接口建立線程（重點）
3）使用Callable和Future建立線程（了解）
4）使用線程池例如用Executor架構
2.1 方式一：繼承Thread類
繼承Thread類建立線程：
- 建立一個繼承于Thread類的子類
- 重寫Thread類的run() --> 将此線程執行的操作聲明在run()中
- 建立Thread類的子類的對象
- 通過此對象調用start()：①啟動目前線程 ② 調用目前線程的run()
//建立線程方式1：繼承thred類，重寫run方法，調用start開啟線程 //注意，線程開啟不一定立即執行，由cpu排程執行 public class TestThred1 extends Thread{ @Override public void run() { for (int i = 0; i < 20; i++) { System.out.println("我在看代碼"+i); } } public static void main(String[] args) { //main線程，主線程 //建立一個線程對象 TestThred1 testThred1 = new TestThred1(); //調用start()方法開啟線程 testThred1.start(); for (int i = 0; i < 2000; i++) { System.out.println("我在學習多線程"+i); } } }
說明兩個問題：
問題一：我們啟動一個線程，必須調用start()，不能調用run()的方式啟動線程。
問題二：如果再啟動一個線程，必須重新建立一個Thread子類的對象，調用此對象的start().
2.2 方式二：實作Runnable接口建立線程
相較于繼承Thread的好處：
1、 通過建立任務，然後線程配置設定的方式來實作多線程，更适合多個線程同時執行任務的情況。
2、 可以避免單繼承所帶來的局限性
//建立線程方式二：實作runnable接口，重寫run方法，執行線程需要丢入runnable接口實作類，調用strat方法
public class TestThread3 implements Runnable{
@Override
public void run() {
//run方法線程體
for (int i = 0; i < 200; i++) {
System.out.println("我在看代碼："+i);
}
}
public static void main(String[] args) {
//建立runnable接口的實作類對象
TestThread3 testThread3 = new TestThread3();
//建立線程對象,通過線程對象來開啟線程，代理
// Thread thread =new Thread(testThread3);
// thread.start();
new Thread(testThread3).start();
for (int i = 0; i < 200; i++) {
System.out.println("我在學習多線程："+i);
}
}
}
2.3 方式三：實作Callable接口建立線程
1.實作Callable接口，需要傳回值類型
2.重寫call方法，需要抛出異常
3.建立目标對象
4.建立執行服務 ExecutorService service = Executors.newFixedThreadPool(3);
5.送出執行 Future result1 =service.submit(t1);
6.擷取結果 System.out.println(result1.get());
7.關閉服務 service.shutdownNow();
public class TestCallable implements Callable<Boolean> {
@Override
public Boolean call() throws Exception {
System.out.println("123");
return true;
}
public static void main(String[] args) {
TestCallable t1 =new TestCallable();
TestCallable t2 =new TestCallable();
TestCallable t3 =new TestCallable();
//建立執行服務：（線程池）
ExecutorService service = Executors.newFixedThreadPool(3);
//送出執行
Future<Boolean> result1 =service.submit(t1);
Future<Boolean> result2 =service.submit(t2);
Future<Boolean> result3 =service.submit(t3);
try {
//擷取結果
System.out.println(result1.get());
System.out.println(result2.get());
System.out.println(result3.get());
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
} finally {
//關閉服務
service.shutdownNow();
}
}
}
callable的好處：
1可以定義傳回值
2可以抛出異常
2.4 Lambda表達式
了解Functional interface（函數式接口） 是學習Java 8 Lambda表達式的關鍵。
函數式接口定義：
- 任何接口，如果隻包含唯一一個抽象方法，那麼他就是一個函數式接口。
- 對于函數式接口，我們可以通過lambda表達式來建立該接口的對象。
/*
推導lambda表達式
*/
//1.定義一個接口
interface iLike{
void lambda();
}
//2.實作類
class Like implements iLike{
public void lambda() {
System.out.println("i like lambda");
}
}
public class TestLambda {
//3.靜态内部類
static class Like2 implements iLike{
public void lambda() {
System.out.println("lambda2");
}
}
public static void main(String[] args) {
iLike like =new Like();
like.lambda();
iLike like2 =new Like2();
like2.lambda();
//4.局部内部類
class like3 implements iLike{
public void lambda() {
System.out.println("lambda3");
}
}
iLike like3 = new like3();
like3.lambda();
//5.匿名内部類,沒有類名，必須借助接口或者父類
like =new iLike() {
public void lambda() {
System.out.println("lambda4");
}
};
like.lambda();
//6.用lambda簡化
like =() ->{
System.out.println("lambda5");
};
like.lambda();
}
}
使用：
interface iLove{
void love(int a，int b);
}
public class TestLambda2 {
public static void main(String[] args) {
//1 lambda表達式簡化
iLove love =(int a) -> {
System.out.println(a);
};
love.love(1);
//簡化1：參數類型
iLove love2 =(a) -> {
System.out.println(a+a);
};
love2.love(2);
//簡化2：簡化括号（多個參數不能這樣簡化）
iLove love3 =a -> {
System.out.println(a);
};
love3.love(3);
//簡化3：簡化大括号（隻有一行語句的情況下）
iLove love4 =a -> System.out.println(a);
love4.love(4);
}
}
3 多線程使用
3.1 Thread常用方法
Thread類中的常用的方法:
- start():啟動目前線程；調用目前線程的run()
- run(): 通常需要重寫Thread類中的此方法，将建立的線程要執行的操作聲明在此方法中
- currentThread():靜态方法，傳回執行目前代碼的線程
- getName():擷取目前線程的名字
- setName():設定目前線程的名字
- yield():釋放目前cpu的執行權
- join():線上程a中調用線程b的join(),此時線程a就進入阻塞狀态，直到線程b完全執行完以後，線程a才結束阻塞狀态。
- stop():已過時。當執行此方法時，強制結束目前線程。
- sleep(long millitime):讓目前線程“睡眠”指定的millitime毫秒。在指定的millitime毫秒時間内，目前線程是阻塞狀态。
- isAlive():判斷目前線程是否存活
3.2 優先級
線程的優先級：
1.MAX_PRIORITY：10
MIN _PRIORITY：1
NORM_PRIORITY：5 -->預設優先級
2.如何擷取和設定目前線程的優先級：
getPriority():擷取線程的優先級
setPriority(int p):設定線程的優先級
說明：高優先級的線程要搶占低優先級線程cpu的執行權。但是隻是從機率上講，高優先級的線程高機率的情況下被執行。并不意味着隻當高優先級的線程執行完以後，低優先級的線程才執行。
3.3 守護線程
線程的分類：一種是守護線程，一種是使用者線程。
使用者線程：當一個程序不包含任何存活的使用者線程時，進行結束。
守護線程：守護使用者線程，當最後一個使用者線程結束時，所有守護線程跟着結束。
設定方式：t1.setDaemon(true);
3.4 線程安全
3.4.1 問題
// 多個線程同時操作同一個對象
// 買火車票的例子
// 發現問題：多個線程操作同一個導緻資料問題
public class TestThread4 implements Runnable{
//票數
private int ticketNums = 10;
public void run() {
while (true){
if (ticketNums<=0){
break;
}
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNums+"張票");
ticketNums--;
}
}
public static void main(String[] args) {
TestThread4 testThread4 = new TestThread4();
new Thread(testThread4,"小明").start();
new Thread(testThread4,"老師").start();
new Thread(testThread4,"黃牛").start();
}
}
解決辦法：
1加鎖，變成同步方法或同步代碼塊(效率慢)
3.4.2 同步代碼塊
同步代碼塊的方式：
public class TestThread5 implements Runnable{
//票數
private int ticketNums = 10;
// run方法前也可以加鎖，
// 但循環在方法内部，加鎖就隻能等到線程的while結束才會釋放
// 同步方法的方式見後
public void run() {
while (true){
// 同步代碼塊，this鎖對象（main中的testThread5對象）
synchronized (this){
if (ticketNums<=0){
break;
}
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNums+"張票");
ticketNums--;
}
}
}
public static void main(String[] args) {
TestThread5 testThread5 = new TestThread5();
new Thread(testThread5,"小明").start();
new Thread(testThread5,"老師").start();
new Thread(testThread5,"黃牛").start();
}
}
3.4.3 同步方法
同步方法的方式:
public class TestThread6 implements Runnable {
private int ticketNums = 10;
public void run() {
while (true) {
boolean f = sale();
if(!f) break;
}
}
// 通過同步方法的方式加鎖
public synchronized boolean sale() {
if (ticketNums <= 0) return false;
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNums + "張票");
ticketNums--;
return true;
}
public static void main(String[] args) {
TestThread6 testThread6 = new TestThread6();
new Thread(testThread6, "小明").start();
new Thread(testThread6, "老師").start();
new Thread(testThread6, "黃牛").start();
}
}
**注意：**如果線程操作方法或屬性被static修飾了，那麼鎖操作的就是類而不是對象，也就是說無論建立多少個對象，對static屬性或方法的操作都是基于類的！
舉例：沒有static的話，如果多個線程操作不同對象，他們會并行的執行任務，他們是互不相關的；
而有static的話，無論有多少個對象，操作的都是同一個類中的資料！
3.4.4 顯式鎖Lock類
public class TestThread7 implements Runnable {
private int ticketNums = 10;
// 顯式鎖
private Lock lock = new ReentrantLock();
public void run() {
while (true) {
lock.lock();
if (ticketNums <= 0) break;
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNums-- + "張票");
lock.unlock();
}
}
public static void main(String[] args) {
TestThread7 t = new TestThread7();
new Thread(t, "小明").start();
new Thread(t, "老師").start();
new Thread(t, "黃牛").start();
}
}
3.5 公平鎖
公平鎖：排隊，先來後到
非公平鎖：可以插隊
3.6 死鎖
兩個程序都在等待對方上鎖的資源釋放，就會造成死鎖（也可能是多個線程循環等待）：
// 電腦速度剛好合适的話可能較難産生死鎖，直接調試即可
public class demo1 {
public static void main(String[] args) {
Player p = new Player();
Man m = new Man();
new MyThread(p,m).start();
m.say(p);
}
static class MyThread extends Thread{
public Player p;
public Man m;
public MyThread(Player p, Man m) {
this.p = p;
this.m = m;
}
@Override
public void run() {
p.say(m);
}
}
static class Player{
public synchronized void say(Man m){
System.out.println("好耶！！！");
m.say2();
}
public synchronized void say2(){
System.out.println("禁止好耶！！！");
}
}
static class Man{
public synchronized void say(Player p){
System.out.println("禁止好耶！！！");
p.say2();
}
public synchronized void say2(){
System.out.println("禁止禁止好耶！！！");
}
}
}
4 多線程狀态
4.1 概述
//Thread内的源碼
public enum State {
//線程新生
NEW,
//運作
RUNNABLE,
//阻塞
BLOCKED,
//等待
WAITING,
//逾時等待
TIMED_WAITING,
//死亡
TERMINATED;
}
4.2 線程通信
線程通信：
1.線程通信涉及到的三個方法：
- wait():一旦執行此方法，目前線程就進入阻塞狀态，并釋放同步螢幕。
- notify():一旦執行此方法，就會喚醒被wait的一個線程。如果有多個線程被wait，就喚醒優先級高的那個。
- notifyAll():一旦執行此方法，就會喚醒所有被wait的線程。
2.說明：
- 1.wait()，notify()，notifyAll()三個方法必須使用在同步代碼塊或同步方法中。
- 2.wait()，notify()，notifyAll()三個方法的調用者必須是同步代碼塊或同步方法中的同步螢幕。
- 否則，會出現IllegalMonitorStateException異常
- 3.wait()，notify()，notifyAll()三個方法是定義在java.lang.Object類中。
3.面試題：
面試題：sleep() 和 wait()的異同？
1.相同點：一旦執行方法，都可以使得目前的線程進入阻塞狀态。
2.不同點：
1）兩個方法聲明的位置不同：Thread類中聲明sleep() , Object類中聲明wait()
2）調用的要求不同：sleep()可以在任何需要的場景下調用。 wait()必須使用在同步代碼塊或同步方法中
3）關于是否釋放同步螢幕：如果兩個方法都使用在同步代碼塊或同步方法中，sleep()不會釋放鎖，wait()會釋放鎖。
4）sleep需要捕獲異常，wait不需要
4.3 生産者消費者問題
public class Demo4 {
/**
* 多線程通信問題, 生産者與消費者問題
* @param args
*/
public static void main(String[] args) {
Food f = new Food();
new Cook(f).start();
new Waiter(f).start();
}
//廚師
static class Cook extends Thread{
private Food f;
public Cook(Food f) {
this.f = f;
}
@Override
public void run() {
for(int i=0;i<100;i++){
if(i%2==0){
f.setNameAndSaste("老幹媽小米粥","香辣味");
}else{
f.setNameAndSaste("煎餅果子","甜辣味");
}
}
}
}
//服務生
static class Waiter extends Thread{
private Food f;
public Waiter(Food f) {
this.f = f;
}
@Override
public void run() {
for(int i=0;i<100;i++){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
f.get();
}
}
}
//食物
static class Food{
private String name;
private String taste;
//true 表示可以生産
private boolean flag = true;
public synchronized void setNameAndSaste(String name,String taste){
if(flag) {
this.name = name;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.taste = taste;
flag = false;
this.notifyAll();
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public synchronized void get(){
if(!flag) {
System.out.println("服務員端走的菜的名稱是:" + name + ",味道:" + taste);
flag = true;
this.notifyAll();
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
5 線程池Executors
5.1 概述
如果并發的線程數量很多，并且每個線程都是執行一個時間很短的任務就結束了，這樣頻繁建立線程
就會大大降低 系統的效率，因為頻繁建立線程和銷毀線程需要時間. 線程池就是一個容納多個線程的容
器，池中的線程可以反複使用，省去了頻繁建立線程對象的操作，節省了大量的時間和資源。
線程池的好處
- 降低資源消耗。
- 提高響應速度。
- 提高線程的可管理性。
Java中的4種線程池
- 緩存線程池
- 定長線程池
- 單線程線程池
- 周期任務 定長線程池
5.2 緩存線程池
public class Demo {
/** 緩存線程池
* (長度無限制)
* 執行流程:
* 1. 判斷線程池是否存在空閑線程
* 2. 存在則使用
* 3. 不存在,則建立線程 并放入線程池, 然後使用
*/
public static void main(String[] args) {
// 向線程池中加入新的任務 / 指揮線程池執行新的任務
ExecutorService service = Executors.newCachedThreadPool();
service.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
// 讓線程執行久一點保證線程2能建立出來
try {
Thread.sleep(600);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
// lambda表達式形式
service.execute(() -> {
System.out.println(Thread.currentThread().getName());
// 讓該線程死循環，不空閑
while (true) {
}
});
// // main線程睡一會保證線程1執行完
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 使用了線程1
service.execute(() -> System.out.println(Thread.currentThread().getName()));
// 多建立幾個也是用的線程1（電腦差的可能會看到線程3建立出來了）
service.execute(() -> System.out.println(Thread.currentThread().getName()));
}
}
5.3 定長線程池
public class Demo2 {
/**
* 定長線程池：長度是指定的數值
* 任務加入後的執行流程：
* 1. 判斷線程池是否存在空閑線程
* 2. 存在則使用
* 3. 不存在空閑線程,且線程池未滿的情況下,則建立線程 并放入線程池, 然後使用
* 4. 不存在空閑線程,且線程池已滿的情況下,則等待線程池存在空閑線程
*/
public static void main(String[] args) {
ExecutorService service = Executors.newFixedThreadPool(2);
service.execute(()->{
System.out.println(Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
service.execute(()->{
System.out.println(Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
service.execute(()->{
System.out.println(Thread.currentThread().getName());
});
}
}
5.4 單線程線程池
public class Demo3 {
/**
* 單線程線程池 : 效果與定長線程池 建立時傳入數值1 效果一緻.
* 執行流程:
* 1. 判斷線程池 的那個線程 是否空閑
* 2. 空閑則使用
* 3. 不空閑,則等待 池中的單個線程空閑後 使用
*/
public static void main(String[] args) {
ExecutorService service = Executors.newSingleThreadExecutor();
service.execute(()-> System.out.println(Thread.currentThread().getName()));
service.execute(()-> System.out.println(Thread.currentThread().getName()));
service.execute(()-> System.out.println(Thread.currentThread().getName()));
}
}
5.5 周期任務定長線程池
public class Demo4 {
/**
* 周期任務 定長線程池.
* 執行流程:
* 1. 判斷線程池是否存在空閑線程
* 2. 存在則使用
* 3. 不存在空閑線程,且線程池未滿的情況下,則建立線程 并放入線程池, 然後使用
* 4. 不存在空閑線程,且線程池已滿的情況下,則等待線程池存在空閑線程
* <p>
* 周期性任務執行時:
* 定時執行, 當某個時機觸發時, 自動執行某任務 .
*/
public static void main(String[] args) {
ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
/**
* 定時執行一次
* 參數1. runnable類型的任務
* 參數2. 時長數字
* 參數3. 時長數字的機關
*/
service.schedule(() -> {
System.out.println(Thread.currentThread().getName()+" abc");
},3, TimeUnit.SECONDS);
/**
* 周期執行任務（每隔一段時間執行一次任務）
* 參數1：任務
* 參數2：延遲時長數字（第一次執行在什麼時間以後）
* 參數3：周期時長數字（每隔多久執行一次）
* 參數4：時長數字機關
*/
service.scheduleAtFixedRate(() -> {
System.out.println(Thread.currentThread().getName()+" 222");
},3,1, TimeUnit.SECONDS);
}
}
![Java小案例——随機數猜測随機數猜測[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)