多線程的概念：略

多線程的目的：提高效率

主線程：

package demo;
//主線程
public class Demo {
    public static void main(String[] args) {
        function();
        System.out.println(1);
    }
    
    public static void function(){
        for (int i = 0; i < 10000; i++) {
            System.out.println(i);
        }
    }
}
 

這段簡單的代碼，我們發現：

必須要先執行方法輸出完10000次的數字後才可以打印第二行的數字1

那麽有沒有方法，可以做到在執行方法的同時執行第二行的輸出？

Thread類

創建新線程的兩種方法：

第一種：

package demo;

public class SubThread extends Thread {
    //重寫run方法
    public void run(){
        for(int i = 0 ; i< 50 ; i++){
            System.out.println(i+"run");
        }
    }
}

package
 
 demo;

public class ThreadDemo {
    public static void main(String[] args) {
        SubThread st1 = new SubThread();
        st1.start();
        for (int i = 0; i < 50; i++) {
            System.out.println(i+"main");
        }
    }
}

這裏輸出時候，發現打印的run和main隨機出現，交錯出現，而不像以前那樣按順序打印

原因：創建了新的線程，兩條線程由cpu選擇執行，我們無法控制

start方法開啟新的線程，繼承了Thread類因為只有繼承了它才可以操作線程

重寫run方法因為，Thread類本身沒有寫入有意義的run方法，相當於一個模板，供開發者使用

線程名：

每個線程都有自己的名字，主線程名：main，其他新建線程默認名：Thread-n

獲取、修改線程名：

package demo1;

public class NameThread extends Thread {
    public void run(){
        System.out.println(super.getName());
        //輸出：默認是Thread-0，如果修改了，就是hello
    }
}

package demo1;

public class ThreadDemo {
    public static void main(String[] args) {
        NameThread nt1 = new NameThread();
        nt1.setName("hello");
        //修改線程名為hello，主線程不能改名
        nt1.start();
        
        Thread t = Thread.currentThread();
        System.out.println(t.getName());
        //輸出：main
    }
}

Thread類的一個實用方法：

package demo1;

public class ThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            Thread.sleep(1000);
            System.out.println(i);
        }
        //每次打印都會等待一秒，參數是毫秒值
    }
}

第二種創建線程方法：

package demo1;

public class SubRunnable implements Runnable {
    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println(i + "run");
        }
    }
}

package demo1;

public class ThreadDemo {
    public static void main(String[] args) {
        SubRunnable sr1 = new SubRunnable();
        Thread t1 = new Thread(sr1);
        t1.start();
        for (int i = 0; i < 50; i++) {
            System.out.println(i + "main");
        }
    }
}

這種方式好處：

1.接口可以多實現，避免了單繼承的局限性

2.線程和方法分離，更符合面向對象的特點

3.資源實現共享

這兩種方式可以實用匿名內部類實現：

package demo1;

public class ThreadDemo {
    public static void main(String[] args) {
        // 繼承方式
        new Thread() {
            public void run() {
                System.out.println("1");
            }
        }.start();

        // 實現接口方式
        new Thread(new Runnable() {
            public void run() {
                System.out.println(2);
            }
        }).start();

    }
}

線程的狀態：

1.新建狀態：new Thread()創建線程對象

2.運行狀態：使用了start()方法進入運行狀態

3.退出狀態：run方法結束，或者調用了stop方法（已過時，不建議實用）

4.阻塞狀態：有時候使用了start方法，但不一定立即運行，或者運行之後CPU由於一些原因不再分配，由運行狀態轉到阻塞狀態

5.休眠狀態：前邊提到的sleep方法就是這種狀態，也有可能轉到阻塞狀態或者運行狀態

6.等待狀態：wait方法，無限等待，notify方法可以喚醒線程，可能轉到運行或阻塞狀態

註意：受阻塞是等待CPU的資源，休眠等待是放棄CPU的執行

線程池的概念：

一個容器，存入多個線程，需要時候，拿出執行，

運行結束後線程再回到容器中，這種方式可以提高效率

實現線程池：

package demo1;

public class ThreadPoolRunnable implements Runnable {
    public void run(){
        System.out.println(Thread.currentThread().getName()+"線程提交任務");
        //輸出: pool-1-thread-1線程提交任務
        //        pool-1-thread-2線程提交任務
    }

package demo1;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolDemo {
    public static void main(String[] args) {
        //調用工廠類的方法創建線程池
        ExecutorService es1 = Executors.newFixedThreadPool(2);
        es1.submit(new ThreadPoolRunnable());
        es1.submit(new ThreadPoolRunnable());
        //運行後不會停
        
        es1.shutdown();//銷毀線程池，不常用
    }
}

實現線程的Callable接口方式：

它彌補了Runnable方式的缺陷：無法拋出異常，並且有返回值

使用方法和Runnable方式基本一致：

示例：

package demo1;

import java.util.concurrent.Callable;

public class ThreadPoolCallable implements Callable<String>{
    public String call(){
        return "a";
    }
}

package demo1;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ThreadPoolDemo {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService es1 = Executors.newFixedThreadPool(2);
        Future<String>f1 = es1.submit(new ThreadPoolCallable());
        String s1 = f1.get();
        System.out.println(s1);
        //得到返回值，輸出a
    }
}

簡單應用：多線程異步計算

使用兩個線程計算求和：

package demo1;

import java.util.concurrent.Callable;

public class GetSumCallable implements Callable<Integer> {
    private int a;

    public GetSumCallable(int a) {
        this.a = a;
    }

    public Integer call() {
        int sum = 0;
        for (int i = 0; i <= a; i++) {
            sum += i;
        }
        return sum;
    }
}

package demo1;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ThreadPoolDemo {
    public static void main(String[] args) throws Exception {
        ExecutorService es1 = Executors.newFixedThreadPool(2);
        Future<Integer> f1 = es1.submit(new GetSumCallable(100));
        Future<Integer> f2 = es1.submit(new GetSumCallable(300));
        System.out.println(f1.get());
        System.out.println(f2.get());
        es1.shutdown();
    }
}

Java學習筆記44（多線程一）