初識多線程之基礎知識與經常使用方法

時間 2019-12-06

標籤識多線程基礎知識經常使用方法简体版

原文原文鏈接

1.線程與進程的描述：

1.1進程：每一個進程都有獨立的代碼和數據空間（進程上下文），進程間的切換會有較大的開銷，一個進程包含1~n個線程。（進程是資源分配的最小單位）
　　java

1.2線程:同一類線程共享代碼和數據空間，每一個線程有獨立的運行棧和程序計數器(PC)，線程切換開銷小。（線程是cpu調度的最小單位）多線程

2.實現多線程的經常使用方式：

繼承Thread類 extends Threadide

實現Runnable接口 implements Runnable函數

內部匿名類測試

Thread t = new Thread(new Runnable() {    
});

3.實現多線程的經常使用方式：

推薦使用Runnable接口:緣由有二:1 Java中的類僅僅只支持單繼承，而接口支持多繼承
2 使用Runnable接口能夠輕鬆的實現多個線程間的資源共享this

4.線程的五種狀態：

5.經常使用函數說明：

5.1:join線程(控制線程):
Thread提供了讓一個線程等待另外一個線程完成的方法--join方法，當在某個程序執行流中調用其餘線程的join方法，調用線程將被阻塞，直到被join方法加入的join線程執行完畢爲止。

列子：spa

 1 /**
 2  * Created by 123 on 2017/07/02.
 3  */
 4 public class TestJoin {
 5     public static void main(String[] args) throws InterruptedException {
 6         new JoinThread("新線程").start();
 7         for (int i = 0; i < 10; i++) {
 8                if (i==5){
 9                    JoinThread j1=new JoinThread("被join的線程");
10                    j1.start();
11                    j1.join();
12                }
13             System.out.println(Thread.currentThread().getName()+" "+i);
14         }
15     }
16 }

join方法使用（測試類）

 1 /**
 2  * Created by 123 on 2017/07/02.
 3  */
 4 public class JoinThread extends Thread {
 5     public JoinThread(String name) {
 6         super(name);
 7     }
 8 
 9     public void run(){
10         for (int i=1;i<=10;i++){
11             System.out.println(Thread.currentThread().getName()+"  "+i);
12         }
13     }
14 }

線程執行體

5.2:yield線程(線程讓步):線程的優先級

Thread.yield()方法做用是：暫停當前正在執行的線程對象，並執行其餘線程。
yield()應該作的是讓當前運行線程回到可運行狀態，以容許具備相同優先級的其餘線程得到運行機會。所以，使用yield()的目的是讓相同優先級的線程之間能適當的輪轉執行。可是，實際中沒法保證yield()達到讓步目的，由於讓步的線程還有可能被線程調度程序再次選中。

 1 import javax.naming.Name;
 2 
 3 /**
 4  * Created by 123 on 2017/07/02.
 5  */
 6 public class ThreadYeild extends Thread {
 7     String name;
 8 
 9     public ThreadYeild(String name) {
10         super(name);
11         this.name = name;
12     }
13 
14     @Override
15     public void run() {
16         for (int i = 0; i < 50; i++) {
17             System.out.println(this.getName()+" "+i);
18             if (i==30){
19                 Thread.yield();
20             }
21         }
22     }
23 }

線程執行體

 1 import javax.naming.Name;
 2 
 3 /**
 4  * Created by 123 on 2017/07/02.
 5  */
 6 public class ThreadYeild extends Thread {
 7     String name;
 8 
 9     public ThreadYeild(String name) {
10         super(name);
11         this.name = name;
12     }
13 
14     @Override
15     public void run() {
16         for (int i = 0; i < 50; i++) {
17             System.out.println(this.getName()+" "+i);
18             if (i==30){
19                 Thread.yield();
20             }
21         }
22     }
23 }

Yeild方法（測試類）

5.3:sleep()函數和yield函數的區別：

                sleep()和yield()的區別):
                1:sleep()使當前線程進入停滯狀態，因此執行sleep()的線程在指定的時間內確定不會被執行；
                yield()只是使當前線程從新回到可執行狀態，因此執行yield()的線程有可能在進入到可執行狀態後立刻又被執行。
                2:sleep()函數也能夠容許優先級較低的線程運行

5.4守護線程：

 1 /**
 2  * Created by 123 on 2017/07/02.
 3  */
 4 public class BackGroundThread implements Runnable {
 5     public void run() {
 6          for (int i=1;i<100000000;i++){
 7              System.out.println("後臺線程執行第"+i+"次");
 8              try {
 9                  Thread.sleep(7);
10              } catch (InterruptedException e) {
11                  e.printStackTrace();
12              }
13          }
14     }
15 }

後臺線程

 1 /**
 2  * Created by 123 on 2017/07/02.
 3  */
 4 public class MyThreads extends Thread {
 5     @Override
 6     public void run() {
 7         for (int i = 1; i <= 4; i++) {
 8             System.out.println("線程1第" + i + "次執行");
 9             try {
10                 Thread.sleep(7);
11             } catch (InterruptedException e) {
12                 e.printStackTrace();
13             }
14         }
15     }
16 }

前臺線程

 1 /**
 2  * Created by 123 on 2017/07/02.
 3  * 守護線程
 4  */
 5 public class TestThread {
 6     //若是前臺線程執行i次，後臺線程執行i+1次，由於還有main線程
 7     public static void main(String[] args) {
 8         Thread t1 = new MyThreads();
 9         Thread t2 = new Thread(new BackGroundThread());
10         t2.setDaemon(true);    //設置爲守護線程
11         t1.start();
12         t2.start();
13     }
14 }