Java多線程詳細知識總結(jié) 用實例代碼展示具體的使用

* 多線程的創(chuàng)建，方式一：繼承于Thread類
 * 1. 創(chuàng)建一個繼承于Thread類的子類
 * 2. 重寫Thread類的run() --> 將此線程執(zhí)行的操作聲明在run()中
 * 3. 創(chuàng)建Thread類的子類的對象
 * 4. 通過此對象調(diào)用start()
 * 例子：遍歷100以內(nèi)的所有的偶數(shù)

//1、創(chuàng)建一個繼承于Thread類的子類
class Thread01 extends Thread {
    //2、重寫Thread類的run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        //3、創(chuàng)建Thread類的子類的對象
        Thread01 thread01 = new Thread01();
        //4.通過此對象調(diào)用start()
        thread01.start();

        //創(chuàng)建第二個線程
        Thread01 thread02 = new Thread01();

        //注意：這里我們不能直接手動調(diào)用 run()方法
        //thread01.run();

        //注意：當我們再次調(diào)用start()時會直接報錯：IllegalThreadStateException,所以一個線程只能用一次
        //thread01.start();

        thread02.start();


        //當前操作仍然是在main線程中執(zhí)行
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i + "主線程被執(zhí)行了");
            }

        }
    }
}

public class ThreadTest01 {
    public static void main(String[] args) {

        //線程一：偶數(shù)
        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    if (i % 2 == 0) {
                        System.out.println(Thread.currentThread().getName() + "線程一偶數(shù)的執(zhí)行數(shù)：" + i);
                    }
                }
            }
        }.start();


        //線程二：奇數(shù)
        new Thread() {
            @Override
            public void run() {

                for (int i = 0; i < 100; i++) {
                    if (i % 2 != 0) {
                        System.out.println(Thread.currentThread().getName() + "線程二奇數(shù)的執(zhí)行數(shù)：" + i);
                    }
                }
            }
        }.start();
    }
}

* @description: 多線程具體方法的使用
 * @date 2021/4/16 18:32
 */


class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority() + ":" + i);

                //設(shè)置線程睡眠時間
               /* try {
                    sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }*/
            }
            //當滿足當前條件時，終止線程
            /*if (i % 20 == 0) {
                yield();
            }*/


        }

    }
}

public class ThreadMethodTest {
    public static void main(String[] args) {
        MyThread thread = new MyThread();

        thread.start();
        //給主線程命名
        thread.setName("我是線程一號");
        //將分線程優(yōu)先級設(shè)置成最大
        thread.setPriority(Thread.MAX_PRIORITY);

        Thread.currentThread().setName("我是主線程");
        //將主線程的優(yōu)先級設(shè)置成最小
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);

        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority() + ":" + i);
            }
            //join()表示：線程A中調(diào)用線程B的join()方法,那么此時線程A進入阻塞狀態(tài)，直到線程B完全執(zhí)行完以后，線程A才
            //結(jié)束阻塞狀態(tài)。
            /*if (i == 20) {
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }*/

        }
        //isAlive():判斷當前線程是否存活
//        System.out.println("當前線程是否存活：" + thread.isAlive());


    }
}

class Window extends Thread {

    private static int ticket = 100;

    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                System.out.println(getName() + "買票編碼號為：" + ticket);
                ticket--;
            } else {
                break;
            }
        }
    }
}

public class TicketWindowTest {
    public static void main(String[] args) {
        //創(chuàng)建線程
        Window w1 = new Window();
        Window w2 = new Window();
        Window w3 = new Window();

        //設(shè)置線程名字
        w1.setName("窗口一：");
        w2.setName("窗口二：");
        w3.setName("窗口三：");

        //開啟線程
        w1.start();
        w2.start();
        w3.start();
    }
}

 1、同步代碼塊：
    synchronized (對象){
          // 需要被同步的代碼；
    }

2、synchronized還可以放在方法聲明中，表示整個方法為同步方法。
	例如：
    public synchronized void show (String name){ 
            ….
   }

class Windows02 implements Runnable {

    private int ticke = 100;

    @Override
    public void run() {
        while (true) {
            //使用同步代碼方式來解決線程安全問題，this：表示當前對象：【W(wǎng)indows02】
//            synchronized (this) {
//                if (ticke > 0) {
//                    try {
//                        Thread.sleep(100);
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }
//                    System.out.println(Thread.currentThread().getName() + "購票號碼為：" + ticke);
//                    ticke--;
//                } else {
//                    break;
//                }
//            }

            show();
        }
    }

    //這里我們直接使用【同步方法】的方式來處理線程安全問題
    //在方法中加入：synchronized的效果等同上面的this，因為指代的都是當前對象，只是在同步方法中幫我們做了隱試操作。
    private synchronized void show() {
        if (ticke > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "購票號碼為：" + ticke);
            ticke--;
        }
    }
}

public class TickeWindowTest02 {
    public static void main(String[] args) {
        Windows02 windows = new Windows02();

        Thread thread = new Thread(windows);
        Thread thread01 = new Thread(windows);
        Thread thread02 = new Thread(windows);

        thread.setName("窗口一：");
        thread01.setName("窗口二：");
        thread02.setName("窗口三：");

        thread.start();
        thread01.start();
        thread02.start();


    }
}

//死鎖的演示
class A {
    public synchronized void foo(B b) { //同步監(jiān)視器：A類的對象：a
        System.out.println("當前線程名: " + Thread.currentThread().getName()
                + " 進入了A實例的foo方法"); // ①
//		try {
//			Thread.sleep(200);
//		} catch (InterruptedException ex) {
//			ex.printStackTrace();
//		}
        System.out.println("當前線程名: " + Thread.currentThread().getName()
                + " 企圖調(diào)用B實例的last方法"); // ③
        b.last();
    }

    public synchronized void last() {//同步監(jiān)視器：A類的對象：a
        System.out.println("進入了A類的last方法內(nèi)部");
    }
}

class B {
    public synchronized void bar(A a) {//同步監(jiān)視器：b
        System.out.println("當前線程名: " + Thread.currentThread().getName()
                + " 進入了B實例的bar方法"); // ②
//		try {
//			Thread.sleep(200);
//		} catch (InterruptedException ex) {
//			ex.printStackTrace();
//		}
        System.out.println("當前線程名: " + Thread.currentThread().getName()
                + " 企圖調(diào)用A實例的last方法"); // ④
        a.last();
    }

    public synchronized void last() {//同步監(jiān)視器：b
        System.out.println("進入了B類的last方法內(nèi)部");
    }
}

public class DeadLock implements Runnable {
    A a = new A();
    B b = new B();

    public void init() {
        Thread.currentThread().setName("主線程");
        // 調(diào)用a對象的foo方法
        a.foo(b);
        System.out.println("進入了主線程之后");
    }

    public void run() {
        Thread.currentThread().setName("副線程");
        // 調(diào)用b對象的bar方法
        b.bar(a);
        System.out.println("進入了副線程之后");
    }

    public static void main(String[] args) {
        DeadLock dl = new DeadLock();
        new Thread(dl).start();
        dl.init();
    }
}

class Number implements Runnable {
    private int number = 1;
    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                //因為現(xiàn)在使用的是當前對象，所以前面省略this.
                //如果使用的是其他對象，那么就用對象.的方式去調(diào)用該方法
                notify();
                if (number <= 100) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " ：" + "打印數(shù)為" + number);
                    number++;
                    try {
                        //調(diào)用該方法時，線程進入阻塞狀態(tài)
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }
}
public class CommunicationTest {
    public static void main(String[] args) {
        Number number = new Number();
        Thread thread = new Thread(number);
        Thread thread01 = new Thread(number);
        thread.setName("線程一");
        thread01.setName("線程二");

        thread.start();
        thread01.start();
    }
}

//1.創(chuàng)建一個實現(xiàn)Callable的實現(xiàn)類
class NumThread implements Callable<Integer> {
    //2.實現(xiàn)call方法，將此線程需要執(zhí)行的操作聲明在call()中
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}


public class ThreadNew {
    public static void main(String[] args) {
        //3.創(chuàng)建Callable接口實現(xiàn)類的對象
        NumThread numThread = new NumThread();
        //4.將此Callable接口實現(xiàn)類的對象作為傳遞到FutureTask構(gòu)造器中，創(chuàng)建FutureTask的對象
        FutureTask<Integer> futureTask = new FutureTask<Integer>(numThread);
        //5.將FutureTask的對象作為參數(shù)傳遞到Thread類的構(gòu)造器中，創(chuàng)建Thread對象，并調(diào)用start()
        new Thread(futureTask).start();

        try {
            //6.獲取Callable中call方法的返回值
            //get()返回值即為FutureTask構(gòu)造器參數(shù)Callable實現(xiàn)類重寫的call()的返回值。
            Integer sum = futureTask.get();
            System.out.println("總和為：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

class NumberThread implements Runnable{

    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

class NumberThread1 implements Runnable{

    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

public class ThreadPool {

    public static void main(String[] args) {
        //1. 提供指定線程數(shù)量的線程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //設(shè)置線程池的屬性
//        System.out.println(service.getClass());
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();


        //2.執(zhí)行指定的線程的操作。需要提供實現(xiàn)Runnable接口或Callable接口實現(xiàn)類的對象
        service.execute(new NumberThread());//適合適用于Runnable
        service.execute(new NumberThread1());//適合適用于Runnable

//        service.submit(Callable callable);//適合使用于Callable
        //3.關(guān)閉連接池
        service.shutdown();
    }

}