如何實現一個多線程

本篇文章為大家展示了如何實現一個多線程，內容簡明扼要并且容易理解，絕對能使你眼前一亮，通過這篇文章的詳細介紹希望你能有所收獲。

傳統線程測試：* 子線程循環10次，接著主線程循環100次，接著又回到子線程循環10次，接著再回到主線程又循環100次，如此循環50次，請寫出程序。

 一、傳統方法（隱式鎖）實現

package com.lau.javabase.lock;

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

/**
 * 傳統線程測試：
 * 子線程循環10次，接著主線程循環100次，接著又回到子線程循環10次，接著再回到主線程又循環100次，如此循環50次，請寫出程序。
 */
public class TraditionThreadExerciseTest {
    volatile Boolean executeInTurn = true;

    public synchronized void subTask(int times) throws Exception {
        while(!executeInTurn){
            this.wait();
        }

        for(int i = 1; i <= 10; i++){
            System.out.println("子任務內部運行第" + i + "次，" + "總第" + times + "次");
        }

        executeInTurn = false;

        this.notify();
    }

    public synchronized void mainTask(int times) throws Exception {
        while(executeInTurn){
            this.wait();
        }

        for(int i = 1; i <= 100; i++){
            System.out.println("主任務內部運行第" + i + "次，" + "總第" + times + "次");
        }

        executeInTurn = true;
        this.notify();
    }

    /**
     * @Description:特別注意：不能將主線程和子線程循環50次的調用寫在一個for循環里，
     * 因為這樣會導致后面的跑到前面去，引發錯序打印問題
     * @param args
     * @throws InterruptedException
     */
    public static void main(String[] args) throws InterruptedException {
        TraditionThreadExerciseTest test = new TraditionThreadExerciseTest();

        ExecutorService threadPool = Executors.newFixedThreadPool(4);

        threadPool.submit(() -> {
            try {
                for(int i = 1; i <= 50; i++) {
                    test.subTask(i);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "subThread");

        threadPool.submit(() -> {
            try {
                for(int i = 1; i <= 50; i++) {
                    test.mainTask(i);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "mainThread");

        threadPool.shutdown();
    }
}

二、顯示鎖實現

package com.lau.javabase.lock;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 傳統線程測試：
 * 子線程循環10次，接著主線程循環100次，接著又回到子線程循環10次，接著再回到主線程又循環100次，如此循環50次，請寫出程序。
 */
public class TraditionThreadLockTest {
    volatile Boolean executeInTurn = true;

    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    public void subTask(int times) throws Exception {
        try{
            lock.lock();

            while(!executeInTurn){
                condition.await();
            }

            for(int i = 1; i <= 10; i++){
                System.out.println("子任務內部運行第" + i + "次，" + "總第" + times + "次");
            }

            executeInTurn = false;

            condition.signal();
        }
        finally {
            lock.unlock();
        }
    }

    public void mainTask(int times) throws Exception {
        try{
            lock.lock();

            while(executeInTurn){
                condition.await();
            }

            for(int i = 1; i <= 100; i++){
                System.out.println("主任務內部運行第" + i + "次，" + "總第" + times + "次");
            }

            executeInTurn = true;
            condition.signal();
        }
        finally {
            lock.unlock();
        }
    }

    /**
     * @Description:特別注意：不能將主線程和子線程循環50次的調用寫在一個for循環里，
     * 因為這樣會導致后面的跑到前面去，引發錯序打印問題
     * @param args
     * @throws InterruptedException
     */
    public static void main(String[] args) throws InterruptedException {
        TraditionThreadLockTest test = new TraditionThreadLockTest();

        ExecutorService threadPool = Executors.newFixedThreadPool(4);

        threadPool.submit(() -> {
            try {
                for(int i = 1; i <= 50; i++) {
                    test.subTask(i);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "subThread");

        threadPool.submit(() -> {
            try {
                for(int i = 1; i <= 50; i++) {
                    test.mainTask(i);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "mainThread");

        threadPool.shutdown();
    }
}

上述內容就是如何實現一個多線程，你們學到知識或技能了嗎？如果還想學到更多技能或者豐富自己的知識儲備，歡迎關注億速云行業資訊頻道。