Java多线程第二节-线程的基本使用

1.线程中经常使用的方法介绍

CLASS:Thread类【java.lang.Thread】

INTERFACE:Runnable【java.lang.Runnable】

里面都有一个方法，由于Thread也实现了Runnable接口

public abstract void run();//Runnable

@Override
public void run() {//Thread
    if (target != null) {
        target.run();
    }
}

 

CLASS:Thread类【java.lang.Thread】经常使用方法

1.线程的建立(构造函数)

    a:    Thread()

    b:    Thread(String name)

    c:    Thread(Runnable target)

    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();
    }
}

输出结果

这里有一个关键方法join()，主线程会等待子线程执行完时才会执行

这里主要就是几个关键的方法的实现，sleep 和 yield 还有 join的用法

列子都在上面的github地址里面，谢谢