多线程之常见方法使用

多线程之常见方法使用 多线程之常见方法使用 start和run

首先看调用run方法

代码示例:

package com.wxit.test02;

import lombok.extern.slf4j.Slf4j;


@Slf4j(topic = "c.Test")
public class Test {

    public static void main(String[] args) {
        Thread thread = new Thread("t1") {
            @Override
            public void run() {
                log.debug("开始执行t1线程");
            }
        };

        thread.run();
        log.debug("主线程正在执行....");
    }
}

**控制台输出 **

19:27:46.721 c.Test [main] - 开始执行t1线程
19:27:46.742 c.Test [main] - 主线程正在执行....

程序仍然在main线程中运行,而且是同步执行的

---

调用start方法

package com.wxit.test02;

import lombok.extern.slf4j.Slf4j;


@Slf4j(topic = "c.Test")
public class Test {

    public static void main(String[] args) {
        Thread thread = new Thread("t1") {
            @Override
            public void run() {
                log.debug("开始执行t1线程");
            }
        };

        thread.start();
        log.debug("主线程正在执行....");
    }
}

控制台输出:

19:32:28.911 c.Test [main] - 主线程正在执行....
19:32:28.911 c.Test [t1] - 开始执行t1线程

可以看出程序在t1线程中运行了

---

小结

• 直接调用run方法是在主线程中执行了run方法，没有启动新的线程
• 直接使用start是启动新的线程，通过新的线程间接执行run中的代码

sleep与 yield

sleep

1. 调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）
2. 其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException
3. 睡眠结束后的线程未必会立刻得到执行
4. 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性

yield

1. 调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，然后调度执行其它线程
2. 具体的实现依赖于 *** 作系统的任务调度器

线程优先级

• 线程优先级会提示（hint）调度器优先调度该线程，但它仅仅是一个提示，调度器可以忽略它
• 如果 cpu 比较忙，那么优先级高的线程会获得更多的时间片，但 cpu 闲时，优先级几乎没作用

代码示例：

package com.wxit.test02;


public class Test02 {
    public static void main(String[] args) {
        Runnable r1 = () -> {
            int count = 0;
            for (; ; ) {
                System.out.println("--------1" + count++);
            }
        };
        Runnable r2 = () -> {
            int count = 0;
            for (; ; ) {
//                Thread.yield();
                System.out.println("                --------2" + count++);
            }
        };

        Thread t1 = new Thread(r1, "t1");
        Thread t2 = new Thread(r2, "t2");

        t1.setPriority(Thread.MIN_PRIORITY);
        t2.setPriority(Thread.MAX_PRIORITY);

        t1.start();
        t2.start();
    }
}

查看源码发现线程优先级有三种

    
    public final static int MIN_PRIORITY = 1;

   
    public final static int NORM_PRIORITY = 5;(默认优先级)

    
    public final static int MAX_PRIORITY = 10;

---

join方法

首先引出为什么要使用join

案例说明,执行的结果是？

package com.wxit.test02;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;


@Slf4j(topic = "c.Test03")
public class Test03 {

    static int r = 0;
    public static void main(String[] args) {
        test01();
    }

    static private void test01(){
        log.debug("开始执行....");
        Thread t1 = new Thread(() -> {
            log.debug("开始执行线程中run方法....");
            sleep(1);
            log.debug("睡眠结束....");
            r = 10;
        });
        t1.start();
        log.debug("结果为:{}",r);
        log.debug("主线程执行结束");
    }

    public static void sleep(int i) {
        try {
            TimeUnit.SECONDS.sleep(i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

执行结果：

20:58:02.833 c.Test03 [main] - 开始执行....
20:58:02.886 c.Test03 [Thread-0] - 开始执行线程中run方法....
20:58:02.886 c.Test03 [main] - 结果为:0
20:58:02.888 c.Test03 [main] - 主线程执行结束
20:58:03.894 c.Test03 [Thread-0] - 睡眠结束....

Process finished with exit code 0

分析

• 因为主线程和线程 t1 是并行执行的，t1 线程需要 1 秒之后才能算出 r=10
• 而主线程一开始就要打印 r 的结果，所以只能打印出 r=0

解决方法

• 用 join，加在 t1.start() 之后即可

在t1.start() 之后

调用join方法之后，控制台输出为:

21:01:12.347 c.Test03 [main] - 开始执行....
21:01:12.388 c.Test03 [Thread-0] - 开始执行线程中run方法....
21:01:13.389 c.Test03 [Thread-0] - 睡眠结束....
21:01:13.389 c.Test03 [main] - 结果为:10
21:01:13.389 c.Test03 [main] - 主线程执行结束

应用之同步

以调用方角度来讲，如果

• 需要等待结果返回，才能继续运行就是同步
• 不需要等待结果返回，就能继续运行就是异步

等待多个结果

问，下面代码 花费大约多少秒？

package com.wxit.test02;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;


@Slf4j(topic = "c.Test04")
public class Test04 {
    static int r1 = 0;
    static int r2 = 0;

    public static void main(String[] args) throws InterruptedException {
       log.debug("开始。。。");
        test01();
    }

    static private void test01() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            sleep(1);
            r1 = 10;
        });
        Thread t2 = new Thread(() -> {
            sleep(2);
            r2 = 20;
        }, "t2");
        long start = System.currentTimeMillis();
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        long end = System.currentTimeMillis();
        log.debug("r1:{},r2:{},花费时间:{}",r1,r2,end - start);
    }

    public static void sleep(int i) {
        try {
            TimeUnit.SECONDS.sleep(i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

控制台输出如下：

21:12:08.296 c.Test04 [main] - 开始。。。
21:12:10.352 c.Test04 [main] - r1:10,r2:20,花费时间:2009