Java多線程（四）

Java多線程（一）：
https://blog.csdn.net/Veer_c/article/details/103842078
Java多線程（二）：
https://blog.csdn.net/Veer_c/article/details/103842263
Java多線程（三）：
https://blog.csdn.net/Veer_c/article/details/103842317
Java多線程（四）：
https://blog.csdn.net/Veer_c/article/details/103842602

線程組

線程組：Java中使用ThreadGroup來表示線程組，它可以對一批線程進行分類管理，Java允許程序直接對線程組進行控制。默認情況下，所有的線程都屬於主線程組。
public final ThreadGroup getThreadGroup():獲取線程對應的線程組對象，我們也可以給線程設置分組。
Thread(ThreadGroup group, Runnable target)
案例1：創建線程獲取對應的線程組對象，並獲取名稱
案例2：創建線程組對象，給線程分配線程組

public class MyRunnable implements Runnable{
    @Override
    public void run() {
    }
}
public class MyThread extends Thread{
    @Override
    public void run() {
    }
}
public class Test {
    public static void main(String[] args) {
        // 案例1：創建線程獲取對應的線程組對象，並獲取名稱
        //創建兩個線程
        MyThread mt1 = new MyThread();
        MyThread mt2 = new MyThread();
        //獲取上面兩個線程對應的線程組對象
        ThreadGroup tg1 = mt1.getThreadGroup();
        ThreadGroup tg2 = mt2.getThreadGroup();
        //獲取線程組對象的名稱
        System.out.println(tg1.getName());//main--主線程祖，默認情況下，每一個線程默認都屬於主線程祖
        System.out.println(tg2.getName());
        System.out.println("-----------------");
        //案例2：創建線程組對象，給線程分配線程組
        //public ThreadGroup(String name)
        ThreadGroup tg = new ThreadGroup("劉德華");
        //public Thread(ThreadGroup group,Runnable target)
        Thread t3 = new Thread(tg, new MyRunnable());
        Thread t4 = new Thread(tg, new MyRunnable());
        //獲取t3和t4的線程組對象
        ThreadGroup tg3 = t3.getThreadGroup();
        ThreadGroup tg4 = t4.getThreadGroup();
        System.out.println(tg3.getName());//劉德華
        System.out.println(tg4.getName());//劉德華
    }
}

線程池

使用線程池的原因：
程序啓動一個新線程成本是比較高的，因爲它涉及到要與操作系統進行交互。而使用線程池可以很好的提高性能，尤其是當程序中要創建大量生存期很短的線程時，更應該考慮使用線程池。

線程池的特點：
線程池裏的每一個線程代碼結束後，並不會死亡，而是再次回到線程池中成爲空閒狀態，等待下一個對象來使用。
在JDK5之前，我們必須手動實現自己的線程池，從JDK5開始，Java內置支持線程池

線程池如何創建？
JDK5新增了一個Executors工廠類來產生線程池，有如下幾個方法
public static ExecutorService newFixedThreadPool(int nThreads)

線程池的使用步驟：
1.創建線程池對象
ExecutorService pool = Executors.newFixedThreadPool(2);
2.創建Runnable實例
MyRunnable my = new MyRunnable();
3.提交Runnable實例
pool.submit(my);
pool.submit(my);
4.關閉線程池
pool.shutdown();

案例1：實現Runnable接口實現線程池的使用

package com.edu_08;
public class MyRunnbale implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"---"+i);
        }
    }
}
public class ThreadPool {
    public static void main(String[] args) {
        //線程池如何創建？
        //1.調用工廠類Executors
        //的public static ExecutorService newFixedThreadPool(int nThreads),返回一個線程池對象
        ExecutorService pool = Executors.newFixedThreadPool(2);
        //2.提交給線程池兩個任務，都是打印0-99
        //創建任務
        MyRunnbale my1 = new MyRunnbale();
        MyRunnbale my2 = new MyRunnbale();
        //3.提交任務
        pool.submit(my1);
        pool.submit(my2);
        //關閉線程池
        //void shutdown()
        pool.shutdown();
    }
}

案例2：實現Callable接口實現線程池的使用

package com.edu_09;
import java.util.concurrent.Callable;
public class MyCallable implements Callable{
    //也是一個任務，只不過這個任務需要執行的方法是call(),這個方法有返回值
    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"---"+i);
        }
        return null;
    }
}
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPool {
    public static void main(String[] args) {
        //案例2：實現Callable接口實現線程池的使用
        //1.創建線程池
        ExecutorService pool = Executors.newFixedThreadPool(2);
        //創建一個任務
        MyCallable my1 = new MyCallable();
        MyCallable my2 = new MyCallable();
        //3.提交任務
        pool.submit(my1);
        pool.submit(my2);
        //4.關閉線程池
        pool.shutdown();
    }
}

案例3：實現Callable接口實現線程池的使用，實現多線程求和，1-10之和，1-100之和

package com.edu_10;
import java.util.concurrent.Callable;
public class MyCallable implements Callable<Integer>{//這裏面的泛型就是call()方法返回值的類型
    private int start;
    private int end;
    public MyCallable(int start,int end){
        this.start = start;
        this.end = end;
    }
    @Override
    public Integer call() throws Exception {
        //在這裏求取start--end之間的和
        int sum = 0;
        for (int i = start; i < end+1; i++) {
            sum+=i;
        }
        return sum;
    }
}
package com.edu_10;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class Test {
    public static void main(String[] args) throws Exception{
        //1-10之和，1-100之和
        //1.創建線程池
        ExecutorService pool = Executors.newFixedThreadPool(2);
        //2.創建任務對象，創建任務對象的同時，將參數進行傳遞
        MyCallable my1 = new MyCallable(1,10);
        MyCallable my2 = new MyCallable(1, 100);
        MyCallable my3 = new MyCallable(1, 1000);
        //3.提交任務<T> Future<T> submit(Callable<T> task)
        Future<Integer> res = pool.submit(my1);
        Future<Integer> res2 = pool.submit(my2);
        Future<Integer> res3 = pool.submit(my3);
        //V get()如有必要，等待計算完成，然後獲取其結果。 
        System.out.println(res.get());
        System.out.println(res2.get());
        System.out.println(res3.get());
        //4.關閉線程池
        pool.shutdown();
    }
}

定時器：Timer

public Timer()構造
public void schedule(TimerTask task, long delay) 延遲多久執行任務
public void schedule(TimerTask task,long delay,long period) 延遲多久執行任務，並以後每隔多久執行一次
public boolean cancel() 取消這個任務

TimerTask
public abstract void run()放的是所要執行的任務代碼

案例1：上述方法使用：

package com.edu_11;
import java.util.Timer;
import java.util.TimerTask;
public class TimerTest {
    public static void main(String[] args) {
        //需求：在10秒鐘後，在控制檯打印一句話，helloworld
        //public Timer()構造
        Timer t = new Timer();
        //public void schedule(TimerTask task, long delay)延遲多久執行任務
        t.schedule(new MyTimerTask(t), 10000);
        //public void cancel()終止此計時器
        //t.cancel();//如果在這裏關閉的話，我們還沒等任務執行完畢呢，計時器已經被關閉了
    }
}
//創建TimerTask的子類
class MyTimerTask extends TimerTask{
    private Timer t;
    public MyTimerTask(Timer t){
        this.t = t;
    }
    @Override
    public void run() {
        //此計時器任務要執行的操作。 
        System.out.println("helloworld");
        t.cancel();//當任務被執行完畢之後，關閉定時器
    }
}

案例2：定時刪除文件
所用方法：schedule(TimerTask task, Date time) 安排在指定的時間執行指定的任務

package com.edu_12;
import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
public class Test {
    public static void main(String[] args) throws Exception {
        /* 案例2：定時刪除文件(需要在16：30：00 刪除D：//a.txt文件)
         * 所用方法：schedule(TimerTask task, Date time) 安排在指定的時間執行指定的任務
         * 時間點：16：30：00
         * 任務：刪除D：//a.txt文件        */
        //創建定時器
        Timer t = new Timer();
        String time = "2019-05-20 16:30:00";
        Date date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(time);
        //所用方法：schedule(TimerTask task, Date time) 安排在指定的時間執行指定的任務
        t.schedule(new MyTimerTask(), date);
    }
}
class MyTimerTask extends TimerTask{
    @Override
    public void run() {
        //任務：刪除D：//a.txt文件
        File file = new File("D://a.txt");
        file.delete();
    }
}

多線程相關題：

1.多線程有幾種實現方案，分別是哪幾種?
有倆種實現方案：（1）實現Runnable（）接口；（2）繼承Thread（）類

2.同步有幾種方式，分別是什麼?
同步有三種方式：（1）同步代碼塊；（2）同步方法；（3）靜態同步方法

3.啓動一個線程是run()還是start()?它們的區別?
啓動線程利用start（），run（）方法指的是對象調方法，在主線程裏面執行該方法，start（）指的是開啓線程，在線程裏面執行該方法

4.sleep()和wait()方法的區別：
sleep（）：線程休眠，一定會醒來，而且線程在休眠的時候，不會放下自己手中的鎖
wait（）：線程等待，線程等待的時候會放下自己手中的鎖，線程等待需要喚醒，不喚醒，不執行

5.爲什麼wait(),notify(),notifyAll()等方法都定義在Object類中？
這些方法存在於同步中，使用這些方法的時候，必須表明所屬的鎖，鎖可以是任意對象，但是必須保證是同一把鎖，所以這些方法都定義在Object（）中

Java多線程（四）

線程組

線程池

定時器：Timer

多線程相關題：

linux安裝cuda和cudnn

測試人員都是畫畫大神，讓我看看誰還不會用代碼圖？

Object.values()對象遍歷

我拍了拍Redis，被移出了羣聊···

網絡現代化通向雲原生應用的高速公路

面試官：說說你對序列化的理解

我宣佈，這是我找到的史上AI最全論文體系！

異常及其處理（Java）

Servlet和JSP簡述

Java經典算法（二)

深入理解遞歸算法以及應用場景

創建多少個線程合適

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結