一.概念
1.進程
1.1進程:是一個正在進行中的程序,每一個進程執行都有一個執行順序,該順序是一個執行路徑,或者叫一個控制單元。
1.2線程:就是進程中一個獨立的控制單元,線程在控制着進程的執行,一個進程中至少有一個線程。
1.3舉例java VM:
Java VM啓動的時候會有一個進程java.exe,該進程中至少有一個線程在負責java程序的運行,而且這個線程運行的代碼存在於main方法中,該線程稱之爲主線程。擴展:其實更細節說明jvm,jvm啓動不止一個線程,還有負責垃圾回收機制的線程
2.多線程存在的意義:提高執行效率
二.多線程的創建
1.多線程創建的第一種方式,繼承Thread類
1.1定義類繼承Thread,複寫Thread類中的run方法是爲了將自定義的代碼存儲到run方法中,讓線程運行
1.2調用線程的start方法,該方法有兩個作用:啓動線程,調用run方法
1.3多線程運行的時候,運行結果每一次都不同,因爲多個線程都獲取cpu的執行權,cpu執行到誰,誰就運行,明確一點,在某一個時刻,只能有一個程序在運行。(多核除外),cpu在做着快速的切換,以到達看上去是同時運行的效果。我們可以形象把多線程的運行行爲在互搶cpu的執行權。這就是多線程的一個特性,隨機性。誰搶到,誰執行,至於執行多久,cpu說了算。
1 public class Demo extends Thread{
2 public void run(){
3 for (int x = 0; x < 60; x++) {
4 System.out.println(this.getName()+"demo run---"+x);
5 }
6 }
7
8 public static void main(String[] args) {
9 Demo d=new Demo();//創建一個線程10 d.start();//開啓線程,並執行該線程的run方法11 d.run(); //僅僅是對象調用方法,而線程創建了但並沒有運行12 for (int x = 0; x < 60; x++) {
13 System.out.println("Hello World---"+x);
14 }
15 }
16
17 }
2 創建多線程的第二種方式,步驟:
2.1定義類實現Runnable接口
2.2覆蓋Runnable接口中的run方法:將線程要運行的代碼存放到run方法中
2.3.通過Thread類建立線程對象
2.4.將Runnable接口的子類對象作爲實際參數傳遞給Thread類的構造函數
爲什麼要將Runnable接口的子類對象傳遞給Thread的構造函數:因爲自定義的run方法所屬的對象是Runnable接口的子類對象,所以要讓線程去執行指定對象的run方法,就必須明確該run方法的所屬對象
2.5.調用Thread類的start方法開啓線程並調用Runnable接口子類的方法
1 /* 2 * 需求:簡易買票程序,多個窗口同時賣票
3 */ 4 public class Ticket implements Runnable {
5 private static int tick = 100;
6 Object obj = new Object();
7 boolean flag=true;
8
9 public void run() {
10 if(flag){
11 while (true) {
12 synchronized (Ticket.class) {
13 if (tick > 0) {
14 System.out.println(Thread.currentThread().getName()
15 + "code:" + tick--);
16 }
17 }
18 }
19 }else{
20 while(true){
21 show();
22 }
23 }
24
25 }
26
27 public static synchronized void show() {
28 if (tick > 0) {
29 System.out.println(Thread.currentThread().getName() + "show:"
30 + tick--);
31 }
32 }
33
34 }
35
36 class ThisLockDemo {
37 public static void main(String[] args) {
38 Ticket t = new Ticket();
39
40 Thread t1 = new Thread(t);
41 try {
42 Thread.sleep(10);
43 } catch (Exception e) {
44 // TODO: handle exception45 }
46 t.flag=false;
47 Thread t2 = new Thread(t);
48 //Thread t3 = new Thread(t);
49 //Thread t4 = new Thread(t);50
51 t1.start();
52 t2.start();
53 //t3.start();
54 //t4.start();55 }
56 }
3.實現方式和繼承方式有什麼區別
3.1.實現方式避免了單繼承的侷限性,在定義線程時建議使用實現方式
3.2.繼承Thread類:線程代碼存放在Thread子類run方法中
3.3.實現Runnable:線程代碼存放在接口的子類run方法中
4.多線程-run和start的特點
4.1爲什麼要覆蓋run方法呢:
Thread類用於描述線程,該類定義了一個功能,用於存儲線程要運行的代碼,該存儲功能就是run方法,也就是說該Thread類中的run方法,用於存儲線程要運行的代碼
5.多線程運行狀態
創建線程-運行---sleep()/wait()--凍結---notify()---喚醒
創建線程-運行---stop()—消亡
創建線程-運行---沒搶到cpu執行權—臨時凍結
6.獲取線程對象及其名稱
6.1.線程都有自己默認的名稱,編號從0開始
6.2.static Thread currentThread():獲取當前線程對象
6.3.getName():獲取線程名稱
6.4.設置線程名稱:setName()或者使用構造函數
1 public class Test extends Thread{
2
3 Test(String name){
4 super(name);
5 }
6
7 public void run(){
8 for (int x = 0; x < 60; x++) {
9 System.out.println((Thread.currentThread()==this)+"..."+this.getName()+" run..."+x);
10 }
11 }
12 }
13
14 class ThreadTest{
15 public static void main(String[] args) {
16 Test t1=new Test("one---");
17 Test t2=new Test("two+++");
18 t1.start();
19 t2.start();
20 t1.run();
21 t2.run();
22 for (int x = 0; x < 60; x++) {
23 System.out.println("main----"+x);
24 }
25 }
26 }
三.多線程的安全問題
1.多線程出現安全問題的原因:
1.1.當多條語句在操作同一個線程共享數據時,一個線程對多條語句只執行了一部分,還沒有執行完,另一個線程參與進來執行,導致共享數據的錯誤
1.2.解決辦法:對多條操作共享數據的語句,只能讓一個線程都執行完,在執行過程中,其他線程不可以參與執行
1.3.java對於多線程的安全問題提供了專業的解決方式,就是同步代碼塊:
Synchronized(對象){需要被同步的代碼},對象如同鎖,持有鎖的線程可以在同步中執行,沒有持有鎖的線程即使獲取cpu執行權,也進不去,因爲沒有獲取鎖
2.同步的前提:
2.1.必須要有2個或者2個以上線程
2.2.必須是多個線程使用同一個鎖
2.3.好處是解決了多線程的安全問題
2.4.弊端是多個線程需要判斷鎖,較消耗資源
5.同步函數
定義同步函數,在方法錢用synchronized修飾即可
1 /* 2 * 需求:
3 * 銀行有一個金庫,有兩個儲戶分別存300元,每次存100元,存3次
4 * 目的:該程序是否有安全問題,如果有,如何解決
5 * 如何找問題:
6 * 1.明確哪些代碼是多線程代碼
7 * 2.明確共享數據
8 * 3.明確多線程代碼中哪些語句是操作共享數據的
9 */10
11 public class Bank {
12
13 private int sum;
14
15 Object obj = new Object();
16
17 //定義同步函數,在方法錢用synchronized修飾即可18 public synchronized void add(int n) {
19 //synchronized (obj) {20 sum = sum + n;
21 try {
22 Thread.sleep(10);
23 } catch (InterruptedException e) {
24 // TODO Auto-generated catch block25 e.printStackTrace();
26 }
27 System.out.println("sum=" + sum);
28 //}29
30 }
31
32 }
33
34 class Cus implements Runnable {
35 private Bank b = new Bank();
36
37 public void run() {
38 for (int x = 0; x < 3; x++) {
39 b.add(100);
40 }
41 }
42 }
43
44 class BankDemo {
45 public static void main(String[] args) {
46 Cus c = new Cus();
47 Thread t1 = new Thread(c);
48 Thread t2 = new Thread(c);
49
50 t1.start();
51 t2.start();
52 }
53 }
6.同步的鎖
6.1函數需要被對象調用,那麼函數都有一個所屬對象引用,就是this.,所以同步函數使用的鎖是this
6.2.靜態函數的鎖是class對象
靜態進內存時,內存中沒有本類對象,但是一定有該類對應的字節碼文件對象,類名.class,該對象的類型是Class
6.3.靜態的同步方法,使用的鎖是該方法所在類的字節碼文件對象,類名.class
1 /* 2 * 需求:簡易買票程序,多個窗口同時賣票
3 */ 4 public class Ticket implements Runnable {
5 private static int tick = 100;
6 Object obj = new Object();
7 boolean flag=true;
8
9 public void run() {
10 if(flag){
11 while (true) {
12 synchronized (Ticket.class) {
13 if (tick > 0) {
14 System.out.println(Thread.currentThread().getName()
15 + "code:" + tick--);
16 }
17 }
18 }
19 }else{
20 while(true){
21 show();
22 }
23 }
24
25 }
26
27 public static synchronized void show() {
28 if (tick > 0) {
29 System.out.println(Thread.currentThread().getName() + "show:"
30 + tick--);
31 }
32 }
33
34 }
35
36 class ThisLockDemo {
37 public static void main(String[] args) {
38 Ticket t = new Ticket();
39
40 Thread t1 = new Thread(t);
41 try {
42 Thread.sleep(10);
43 } catch (Exception e) {
44 // TODO: handle exception45 }
46 t.flag=false;
47 Thread t2 = new Thread(t);
48 //Thread t3 = new Thread(t);
49 //Thread t4 = new Thread(t);50
51 t1.start();
52 t2.start();
53 //t3.start();
54 //t4.start();55 }
56 }
7.多線程,單例模式-懶漢式
懶漢式與餓漢式的區別:懶漢式能延遲實例的加載,如果多線程訪問時,懶漢式會出現安全問題,可以使用同步來解決,用同步函數和同步代碼都可以,但是比較低效,用雙重判斷的形式能解決低效的問題,加同步的時候使用的鎖是該類鎖屬的字節碼文件對象
1 /* 2 * 單例模式
3 */ 4 //餓漢式 5 public class Single {
6 private static final Single s=new Single();
7 private Single(){}
8 public static Single getInstance(){
9 return s;
10 }
11
12 }
13
14 //懶漢式15 class Single2{
16 private static Single2 s2=null;
17 private Single2(){}
18 public static Single2 getInstance(){
19 if(s2==null){
20 synchronized(Single2.class){
21 if(s2==null){
22 s2=new Single2();
23 }
24 }
25 }
26 return s2;
27 }
28 }
29
30 class SingleDemo{
31 public static void main(String[] args) {
32 System.out.println("Hello World");
33 }
34 }
8.多線程-死鎖
同步中嵌套同步會出現死鎖
1 /* 2 * 需求:簡易買票程序,多個窗口同時賣票
3 */ 4 public class DeadTest implements Runnable {
5 private boolean flag;
6
7 DeadTest(boolean flag) {
8 this.flag = flag;
9 }
10
11 public void run() {
12 if (flag) {
13 synchronized(MyLock.locka){
14 System.out.println("if locka");
15 synchronized(MyLock.lockb){
16 System.out.println("if lockb");
17 }
18 }
19 } else {
20 synchronized(MyLock.lockb){
21 System.out.println("else lockb");
22 synchronized(MyLock.locka){
23 System.out.println("else locka");
24 }
25 }
26 }
27 }
28 }
29
30 class MyLock{
31 static Object locka=new Object();
32 static Object lockb=new Object();
33 }
34
35 class DeadLockDemo {
36 public static void main(String[] args) {
37 Thread t1 = new Thread(new DeadTest(true));
38 Thread t2 = new Thread(new DeadTest(false));
39
40 t1.start();
41 t2.start();
42 }
43 }
----------技術改變生活,知識改變命運!