java學習之多執行緒-有解無憂

0x00前言和思維導圖

1.什么是行程？什么事執行緒？
我們可以這樣理解，一個qq相當于一個行程，你同時間跟幾個人聊qq你每一個聊天框就相當于執行緒(執行緒就是行程的每一個執行場景/執行單元).
2.對于java來說？
啟動JVM虛擬機然后再呼叫一個main()方法，同時也會呼叫一個垃圾回收執行緒負責看護和回收垃圾，最少現在java有兩個并發的執行緒，
3.行程和執行緒之間的關系，
(1)行程（A）和行程（B）之間記憶體獨立不共享
(2)同一個行程下的，執行緒（A）和執行緒（B）堆記憶體和方法區共享，
(3)但是堆疊記憶體獨立一個執行緒一個堆疊

0x01執行緒的基礎使用

0x1重新構造run方法和繼承Runnable介面

方法1：重新構造方法

用你自己的類去繼承Thread類重寫run方法，有缺陷當你的執行緒不止一個需要很多執行緒的時候你使用這種方法需要去多載run方法

public class JAVA_Threads extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("我是子執行緒"+i);
        }

        }

    public static void main(String[] args)  {
        JAVA_Threads threads=new JAVA_Threads();
        threads.start();

        for (int i = 0; i < 100; i++) {
            System.out.println("我是主執行緒"+i);

        }
    }
}

方法二：繼承Runnable實作run方法

1.繼承介面去實作介面里面的類方法，去面向介面編程，符合面向物件編程的思維，
2.這樣去繼承介面以后還可以繼承其他類，增強代碼的多變性，

class Threads_Test2{
    public static void main(String[] args) {
        Thread thread1=new Thread(new My_thread_run());
        Thread thread2=new Thread(new My_thread_run2());
        thread1.start();
        thread2.start();

    }
}
class My_thread_run implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("這是子執行緒"+i);

        }
    }
}
class My_thread_run2 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("我是子執行緒2個"+i);

        }
    }
}

方法三：匿名內部類構造

public static void main(String[] args)  {

        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("我是子執行緒");
            }
        };
        new Thread(r).start();

        System.out.println("我是主執行緒");
    }

方法四：Callable介面的實作

1.這種方式可獲取執行緒回傳的結果；

class CallableTest {
    public static void main(String[] args) throws Exception {

        MyThread mt = new MyThread();

        FutureTask<Integer> result = new FutureTask<Integer>(mt);

        new Thread(result).start();

        // 獲取運算結果是同步程序，即 call 方法執行完成，才能獲取結果
        Integer sum = result.get();

        System.out.println(sum);
    }
}
class MyThread implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum = 0;

        for (int i = 1; i <= 100; i++) {
            System.out.println("我在執行");
        }

        return sum;
    }

}

0x2獲取一些其他方法

1.設定和獲取執行緒的名字
a.行程物件.getName(); public final String getName()
b.行程物件.setName(); public final synchronized void setName(String name)
2.獲取當前行程的名字
a.public static native Thread currentThread();
b.回傳的物件是一個執行緒，用這個執行緒的Thread.getName

class Mythread_Testo2{
    public static void main(String[] args) {
        Thread thread=new Thread(new My_thread_run2());
        System.out.println(thread.getName());
        thread.setName("我是你子執行緒");
        System.out.println(thread.getName());
        Thread hell= Thread.currentThread();
        System.out.println(hell.getName());

    }
}

0x03sleep()的方法

1.看看原始碼public static native void sleep(long millis)
a.這個方法是一個靜態的方法，直接用類名.的方法呼叫，
b.出現在哪里哪里睡眠，出現在main就是main睡眠，

class Mythread_Test3{
    public static void main(String[] args) {
        Thread thread=new Thread(new My_thread_run2());
        thread.start();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("執行完成");
    }
}

2.中止睡眠
a.public void interrupt()
b.使用該方法以后會爆出錯誤就是cath塊的指令列印錯誤資訊

點擊查看代碼

java.lang.InterruptedException: sleep interrupted
	at java.base/java.lang.Thread.sleep(Native Method)
	at com.zhonglin.www.My_thread_run2.run(JAVA_Threads.java:44)
	at java.base/java.lang.Thread.run(Thread.java:833)
        //睡眠被打斷錯誤資訊

class Mythread_Test3{
    public static void main(String[] args) {
        Thread thread=new Thread(new My_thread_run2());
        thread.start();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread.interrupt();
        System.out.println("執行完成");
    }
}

0x4join()方法

1.public final void join()
2，會將執行緒合并（插入）到當前執行緒中間，阻塞當前執行緒，直到插入執行緒完成以后才繼續當前執行緒，

class Mythread_Test3{
    public static void main(String[] args) {
        Thread thread=new Thread(new My_thread_run2());
        System.out.println("我正在執行");
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("執行完成");
    }
}

0x03執行緒安全

1，最簡單的例子，當你手寫腳本進行弱口令爆破的時候，多執行緒會明顯提高你的效率，你去遍歷字典的時候會發生一種情況，第一個執行緒readline了第一行，如果沒有執行緒安全你的第二個執行緒可能還是readlin的字典的第一行，
2.異步=并發，同步=排隊

0x1同步代碼塊synchironized

1.synchironized(),這個括號中間的一定你想要排隊執行的的共同物件，比如說如果要去取錢一個在ATM取錢是執行緒1，一個在銀行柜臺取錢是執行緒2，那么它們的共同物件就是那個銀行賬戶
2.作業機制，每一個執行緒運行到synchironized前面的時候都會去對比物件，看是否是共享物件，如是相同物件那么就會獲取鎖，下一個執行緒過來發現也是共享物件的話就會等待鎖的釋放，再獲得鎖，

public static class sunchironize_teset implements Runnable{
    private int num = 100;
    private boolean flag = true;
    Object obj = new Object();

    @Override
    public void run() {
        while (flag){
            synchronized (obj){
                if (num==0){
                    flag = false;
                }else {
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println("我是子執行緒"+Thread.currentThread()+"數值"+num--);
                }

            }
        }
    }

}


 public class Test_1 {
    public static void main(String[] args) {
        sunchironize_teset r= new sunchironize_teset();
        new Thread(r).start();
        new Thread(r).start();
        new Thread(r).start();
        new Thread(r).start();
        new Thread(r).start();

    }
}}

0x2進階lock和unlock方法

class MyLockStudy implements Runnable {

    private int count;
    Lock l = new ReentrantLock();

    @Override
    public void run() {
        l.lock();
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + ": 我在執行");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        l.unlock();
    }

    public static void main(String args[]) {
        MyLockStudy runn = new MyLockStudy();
        Thread thread1 = new Thread(runn, "thread1");
        Thread thread2 = new Thread(runn, "thread2");
        Thread thread3 = new Thread(runn, "thread3");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

0x04執行緒池

0x1:newFixedThreadPool

1.建構式：public static ExecutorService newFixedThreadPool(int nThreads)
2.創建的是一個固定大小的執行緒池創造的大小取決有傳入構造引數的int nThreads
3.如果當前執行緒池的執行緒被占滿剩下的執行緒會進入等待等待前面的執行緒結束以后進入佇列進行執行，
4.

class Mypool_1{
    public static void main(String[] args) {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);//創建一個執行緒池
        for (int i = 0; i < 5; i++) {
            final int index = i;
            fixedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    SimpleDateFormat simpleDateFormat=new SimpleDateFormat( "HH:mm:ss");
                    System.out.println("運行時機是"+simpleDateFormat.format(new Date())+" "+index);
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });

        }
        fixedThreadPool.shutdown();

        }
//執行的結果是
//    運行時間是20:03:57 2
//    運行時間是20:03:57 0
//    運行時間是20:03:57 1
//    運行時間是20:03:59 4
//    運行時間是20:03:59 3

}

0x2:newCachedThreadPool

1.建構式：

點擊查看代碼

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());

2.從構造方法可以看出，它創建了一個可快取的執行緒池，當有新的任務提交時，有空閑執行緒則直接處理任務，沒有空閑執行緒則創建新的執行緒處理任務，佇列中不儲存任務

class Mypool_2{
    public static void main(String[] args) {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++) {
            int index=i;
            cachedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    SimpleDateFormat sdf=new SimpleDateFormat("HH:mm:ss");
                    System.out.println("運行的時間"+sdf.format(new Date())+" "+index);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });

        }
        cachedThreadPool.shutdown();
//        運行的時間20:04:39 1
//        運行的時間20:04:39 3
//        運行的時間20:04:39 2
//        運行的時間20:04:39 4
//        運行的時間20:04:39 0

    }
}

0x3:newSingleThreadExecutor

1.它創建了一個單執行緒化的執行緒池，它只會用唯一的作業執行緒來執行任務，保證所有任務按照指定順序執行，
2.為什么是單執行緒？的單執行緒執行指的是執行緒池內部，從執行緒池外的角度看，主執行緒在提交任務到執行緒池時并沒有阻塞，仍然是異步的，

class Mypool_3{
    public static void main(String[] args) {
        ExecutorService singethreadpool=Executors.newSingleThreadExecutor();
        for (int i = 0; i < 5; i++) {
            int index=i;
            singethreadpool.execute(new Runnable() {
                @Override
                public void run() {
                    SimpleDateFormat sdf=new SimpleDateFormat("HH:mm:ss");
                    System.out.println("運行的時間是"+sdf.format(new Date())+" "+index);
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
            });


        }singethreadpool.shutdown();
//        運行的時間是20:37:17 0
//        運行的時間是20:37:19 1
//        運行的時間是20:37:21 2
//        運行的時間是20:37:23 3
//        運行的時間是20:37:25 4


    }
}

0x4:newScheduledThreadPool

1.這個方法創建了一個固定大小的執行緒池，支持定時及周期性任務執行，
看一下延遲執行

 class Mypool_4 {//延遲三秒運行
    public static void main(String[] args) {
        final SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
        System.out.println("提交時間: " + sdf.format(new Date()));
        scheduledThreadPool.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("運行時間: " + sdf.format(new Date()));
            }
        }, 3, TimeUnit.SECONDS);
        scheduledThreadPool.shutdown();
    }
//     提交時間: 20:50:55
//     運行時間: 20:50:58
}

看一下周期方法：使用該執行緒池的scheduleAtFixedRate方法，延遲1秒鐘后每隔3秒執行一次任務，運行結果如下：

 class Mypool_5 {
    public static void main(String[] args) {
        final SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
        System.out.println("提交時間: " + sdf.format(new Date()));
        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("運行時間: " + sdf.format(new Date()));
            }
        }, 1, 3, TimeUnit.SECONDS);
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        scheduledThreadPool.shutdown();
    }
}

0x5小結

其實執行緒池還有很多方法沒有去學習，只是現在在這里大概的學習一下，以后在開發java多執行緒工具的時候會深入的了解，以下各執行緒池的特點
CachedThreadPool:可快取的執行緒池，該執行緒池中沒有核心執行緒，非核心執行緒的數量為Integer.max_value，就是無限大，當有需要時創建執行緒來執行任務，沒有需要時回收執行緒，適用于耗時少，任務量大的情況，

SecudleThreadPool:周期性執行任務的執行緒池，按照某種特定的計劃執行執行緒中的任務，有核心執行緒，但也有非核心執行緒，非核心執行緒的大小也為無限大，適用于執行周期性的任務，

SingleThreadPool:只有一條執行緒來執行任務，適用于有順序的任務的應用場景，

FixedThreadPool:定長的執行緒池，有核心執行緒，核心執行緒的即為最大的執行緒數量，沒有非核心執行緒

0x05總結

多執行緒這一塊知識的話最重要的就是代理池的異步技術，這塊會大大提高我們以后撰寫的工具的運行效率，值得學習

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/458371.html

標籤：其他

上一篇：基于Springboot+JSP+Mybatis實作的員工管理系統

下一篇：Python程式語言學習——實驗作業04——函式的應用