Java多線程第二節-線程的基本使用

時間 2019-11-11

標籤 java 多線程第二線程基本使用欄目 Java 简体版

原文原文鏈接

1.線程中經常使用的方法介紹java

CLASS:Thread類【java.lang.Thread】git

INTERFACE:Runnable【java.lang.Runnable】github

裏面都有一個方法，由於Thread也實現了Runnable接口多線程
public abstract void run();//Runnable
@Override
public void run() {//Thread
    if (target != null) {
        target.run();
    }
}
CLASS:Thread類【java.lang.Thread】經常使用方法ide

1.線程的建立(構造函數)函數

a: Thread()spa

b: Thread(String name)線程

c: Thread(Runnable target)blog

d: Thread(Runnable target,String name)繼承

2.線程裏面的方法

a: void start() 啓動線程

b: static void sleep(Long millis) 線程休眠

c: static void sleep(Long millis,int nanos) 線程休眠

d: void join() 使其餘線程等待當前線程終止不帶參數說明全部線程都進行等待

e: void join(Long millis) 使其餘線程等待當前線程終止帶參數說明其餘線程最長鬚要等待的時候

f: void join(Long millis,int nanos) 使其餘線程等待當前線程終止帶參數說明其餘線程最長鬚要等待的時候

g: static void yield() 當前運行線程釋放資源

h: static Thread currentThread() 返回當前運行的線程引用

2.線程的基本實現

場景：我是農村人，我媽媽是一個節儉的人。雖然如今條件好了，我媽媽不要幹農活了，可是我媽媽在幫我姐姐帶小孩的時候還每天去旁邊的服裝廠剪線頭，我聽媽媽說，服裝廠來活的時候員工們都搶着去拿服裝，搶貨，由於是記件的，因此搶得越多賺的就越多，咱們就來模擬這樣一個場景。

第一種方式

package com.example.learning.多線程;

/**
 * 描述：
 * User: 曾遠征
 * Date: 2018-09-17
 * Time: 21:02
 */
public class EmployeeAThread extends Thread {//第一種方式，繼承Thread

    @Override
    public void run() {//重寫run方法
        System.out.println(getName()+"我是一個員工");
        int count=0;

        boolean isBoolean=true;
        while (isBoolean){
            System.out.println(getName()+"我在拿貨,拿了"+(++count)+"件");
            if (count==100){
                isBoolean=false;
            }

            if (count%5==0){
                try {
                    sleep(3000);//休息3秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println(getName()+"我拿完貨了");
    }

    public static void main(String[] args) {
        Thread thread=new EmployeeAThread();
        thread.setName("大金牙");
        thread.start();
    }
}

第二種方式

package com.example.learning.多線程;

/**
 * 描述：
 * User: 曾遠征
 * Date: 2018-09-17
 * Time: 21:15
 */
public class EmployeeBRunnable implements Runnable {//實現Runnable接口

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"我是一個員工");
        int count=0;

        boolean isBoolean=true;
        while (isBoolean){
            System.out.println(Thread.currentThread().getName()+"我在拿貨,拿了"+(++count)+"件");
            if (count==100){
                isBoolean=false;
            }

            if (count%5==0){
                try {
                    Thread.sleep(3000);//休息3秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println(Thread.currentThread().getName()+"我拿完貨了");
    }

    public static void main(String[] args) {
        Thread thread=new Thread(new EmployeeBRunnable(),"小金牙");
        thread.start();
    }
}

兩個線程一塊兒運行

package com.example.learning.多線程;

/**
 * 描述：兩個線程一塊兒執行
 * User: 曾遠征
 * Date: 2018-09-17
 * Time: 21:19
 */
public class EmployeeABMain {

    public static void main(String[] args) {
        Thread threadA=new EmployeeAThread();
        threadA.setName("大金牙");
        threadA.start();
        Thread threadB=new Thread(new EmployeeBRunnable(),"小金牙");
        threadB.start();
    }
}

結果返回

兩個線程交替運行，爲何不是一塊兒執行呢？由於在同一個時間，同一個處理器，只能運行一個線程，但一個線程運行完時才能運行另一個線程

以上示例在githun地址：

https://github.com/ant-zengyz/Learning/tree/master/src/main/java/com/example/learning/%E5%A4%9A%E7%BA%BF%E7%A8%8B

3.稍微深刻的實現線程

package com.example.learning.多線程.多線程模擬2;

/**
 * 描述：
 * User: 曾遠征
 * Date: 2018-09-17
 * Time: 21:41
 */
public class EmployeeRunnable implements Runnable {

    //volatile保證了線程能夠正確的讀取其餘線程寫入的值，爲何volatile能夠保證，哈哈，我也不懂，可是我知道這樣作是能夠的，大家百度吧
    volatile boolean isBoolean=true;

    @Override
    public void run() {
        while (isBoolean){
            for (int i = 0; i < 3; i++) {
                System.out.println(Thread.currentThread().getName()+"我在拿貨,拿了"+i+"件");
                //讓出處理器時間，下次哪條線程執行仍是未知數
                Thread.yield();
            }
        }
        System.out.println(Thread.currentThread().getName()+"我拿完貨了");
    }
}

package com.example.learning.多線程.多線程模擬2;

/**
 * 描述：
 * User: 曾遠征
 * Date: 2018-09-17
 * Time: 21:46
 */
public class FactoryThread extends Thread {

    @Override
    public void run() {//重寫run方法

        EmployeeRunnable djy=new EmployeeRunnable();
        EmployeeRunnable xjy=new EmployeeRunnable();
        Thread djyThread=new Thread(djy,"大金牙");
        Thread xjyThread=new Thread(xjy,"小金牙");

        djyThread.start();
        xjyThread.start();

        //主線程中止，讓子線程執行
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //讓線程中止
        djy.isBoolean=false;
        xjy.isBoolean=false;

        try {
            xjyThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        new FactoryThread().start();
    }
}

執行結果

能夠看到，有的時候是一人一次執行，有的時候是一個線程連續執行，爲何呢？由於Thread.yield()方法

3.再次稍微的深刻的實現線程（接上一版本進行改造添加）

package com.example.learning.多線程.多線程模擬3;

/**
 * 描述：
 * User: 曾遠征
 * Date: 2018-09-17
 * Time: 21:41
 */
public class EmployeeDPZRunnable implements Runnable {


    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"我在拿貨");
        for (int i = 0; i < 10 ; i++) {
            System.out.println(Thread.currentThread().getName()+"仗着本身胖，拼命拿貨");
        }
        System.out.println(Thread.currentThread().getName()+"我拿完貨了");
    }
}

package com.example.learning.多線程.多線程模擬3;

/**
 * 描述：
 * User: 曾遠征
 * Date: 2018-09-17
 * Time: 21:46
 */
public class FactoryThread extends Thread {

    @Override
    public void run() {//重寫run方法

        EmployeeRunnable djy=new EmployeeRunnable();
        EmployeeRunnable xjy=new EmployeeRunnable();
        Thread djyThread=new Thread(djy,"大金牙");
        Thread xjyThread=new Thread(xjy,"小金牙");

        djyThread.start();
        xjyThread.start();

        //主線程中止，讓子線程執行
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Thread dpzThread=new Thread(new EmployeeDPZRunnable(),"大胖子");

        //讓線程中止
        djy.isBoolean=false;
        xjy.isBoolean=false;

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        dpzThread.start();

        //等待線程執行完成
        try {
            dpzThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("結束了");
    }

    public static void main(String[] args) {
        new FactoryThread().start();
    }
}