3、并发编程-Java线程

并发编程

Java线程

  • 创建和运行线程
  • 查看线程
  • 线程API
  • 线程状态

创建和运行线程

方法一,直接使用new Thread

// 创建线程对象
Thread t = new Thread() {
public void run() { // 要执行的任务
} };
// 启动线程 t.start();

方法二,使用Runnable配置Thread

把【线程】和【任务】(要执行的代码)分开

    • Thread代表线程
  • Runnable可运行的任务(线程要执行的代码)
Runnable runnable = new Runnable() { public void run(){
// 要执行的任务 }
};
// 创建线程对象
Thread t = new Thread( runnable ); // 启动线程
t.start();

Java 8 以后可以使用 lambda 精简代码

 // 创建任务对象
Runnable task2 = () -> log.debug("hello");
// 参数1 是任务对象; 参数2 是线程名字,推荐 
Thread t2 = new Thread(task2, "t2"); 
t2.start();

原理之Thread与Runnable的关系

分析Thread的源码,理清与Runnable的关系

小结:

  • 方法1是把线程和任务合并在一起,方法2是把线程和任务分开了
  • 用Runnable更容易与线程池等高级API配合
  • 用Runnable让任务类脱离了Thread继承体系,更灵活

方法三,FutureTask配合Thread

FutureTask 能够接收 Callable 类型的参数,用来处理有返回结果的情况

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

@Slf4j(topic = "c.MyTest3")
public class MyTest3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask task = new FutureTask<>(new Callable() {
            @Override
            public Integer call() throws Exception {
                log.debug("running...");
                Thread.sleep(3000);
                return 100;
            }
        });

        Thread t = new Thread(task, "MyTest3");
        t.start();

        log.debug("{}", task.get());
    }
}

观察多个线程同时运行

主要是理解

  • 交替执行

  • 谁先谁后,不由我们控制

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.MyTest4")
public class MyTest4 {
    public static void main(String[] args) {
        new Thread(()->{
            while (true) {
                log.debug("t1 running");
            }
        }, "t1").start();

        new Thread(()->{
            while (true) {
                log.debug("t2 running");
            }
        }, "t2").start();
    }
}

查看进程线程的方法

windows

  • 任务管理器可以查看进程和线程数,也可以用来杀死进程
  • tasklist命令查看进程
  • taskkill命令杀死进程

linux

  • ps -ef | grep java 查看所有进程
  • ps -fT -p 查看某个进程(PID)的所有线程
  • kill 杀死进程
  • top 按大写H切换是否显示线程
  • top -H -p 查看某个进程(PID)的所有线程

Java

  • jps命令查看所有java进程
  • jstack 查看某个java进程(PID)的所有线程
  • jconsole来查看某个java进程中线程的运行情况(图形界面)

jconsole远程监控配置

  • 需要以如下方式运行你的java类

     java -Djava.rmi.server.hostname=`ip地址` -Dcom.sun.management.jmxremote - Dcom.sun.management.jmxremote.port=`连接端口` -Dcom.sun.management.jmxremote.ssl=是否安全连接 - Dcom.sun.management.jmxremote.authenticate=是否认证 java类
    
  • 修改/etc/hosts文件将127.0.0.1映射至主机名

如果要认证访问,还需要做如下步骤

  • 复制 jmxremote.password 文件
  • 修改 jmxremote.password 和 jmxremote.access 文件的权限为 600 即文件所有者可读写
  • 连接时填入 controlRole(用户名),R&D(密码)

原理之线程运行

栈与栈帧

Java Virtual Machine Stacks(Java虚拟机栈)

jvm中由堆、栈、方法区所组成,其中栈内存是给线程使用的,每个线程启动后,虚拟机栈就会为其分配一块栈内存

  • 每个栈由多个栈帧(Frame)组成,对应着每次方法调用时所占用的内存

  • 每个线程只能有一个活动栈帧,对应着当前正在执行的那个方法

public class TestFrames {
    public static void main(String[] args) {
        Thread t1 = new Thread(){
            @Override
            public void run() {
                method1(20);
            }
        };
        t1.setName("t1");
        t1.start();
        method1(10);
    }

    private static void method1(int x) {
        int y = x + 1;
        Object m = method2();
        System.out.println(m);
    }

    private static Object method2() {
        Object n = new Object();
        return n;
    }
}

线程上下文切换(Thread Context Switch)

因为以下一些原因导致cpu不在执行当前的线程,转而执行另一个线程的代码

  • 线程的cpu时间片用完
  • 垃圾回收
  • 有更高优先级的线程需要运行
  • 线程自己调用了sleep、yield、wait、join、park、synchronized、lock等方法

当Context Switch发生时,需要由操作系统保存当前线程的状态,并恢复另外一个线程的状态,java中对应的概念就是程序计数器(Program Counter Register),它的作用是记住下一条jvm指令的执行地址,是线程私有的

  • 状态包括程序计数器、虚拟机栈中每个栈帧的信息,如局部变量、操作数栈、返回地址等
  • Context Switch频繁发生会影响性能

常见方法

方法名 static 功能说明 注意
start() 启动一个新线程,在新的线程运行run方法中的代码 start方法只是让线程进入就绪,里面代码不一定立刻运行(cpu的时间片还没分给它),每个线程对象的start方法只能调用一次,如果调用了多次会出现IllegalThreadStateException
run() 新线程启动后会调用的方法 如果在构造Thread对象时传递了Runnable参数,则线程启动后会调用Runnable中的run方法,否则默认不执行任何操作。但可以创建Thread的子类对象,来覆盖默认行为
join() 等待线程运行结束
join(long n) 等待线程运行结束,最多等待n毫秒
getId() 获取线程长整型的id id唯一
getName() 获取线程名
setName() 修改线程名
getPriority() 获取线程优先级
setPriority() 修改线程优先级 java中规定线程优先级是1-10的整数,较大的优先级能提高该线程被cpu调度的几率
getState() 获取线程状态 java中线程状态使用6个enum表示,分别是:NEW/RUNNABLE/BLOCKED/WAITING/TIMED_WAITING/TERMINATED
isInterrupted() 判断是否被打断 不会清除打断标记
isAlive() 线程是否存活(还没有运行完毕)
interrupt() 打断线程 如果被打断线程正在sleep,wait,join会导致被打断的线程抛出InterrputedException,并清除打断标记(false);如果打断的正在运行的线程,则会设置打断标记(true);park的线程被打断,也会设置打断标记(true)
interrupted() static 判断当前线程是否被打断 会清除打断标记(false)
currentThread() static 获取当前正在执行的线程
sleep(long n) static 让当前执行的线程休眠n毫秒,休眠时让出cpu的时间片给其他线程
yield() static 提示线程调度器让出当前线程对cpu的使用 主要是为了测试和调试

start与run

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

yield与sleep

sleep

  1. 调用sleep会让当前线程从Running进入Timed Waiting状态(阻塞)
import lombok.extern.slf4j.Slf4j;

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

    public static void main(String[] args) {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        t1.start();
        log.debug("t1 state: {}", t1.getState());

        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("t1 state: {}", t1.getState());
    }
}
  1. 其他线程可以使用interrupt方法打断正在睡眠的线程,这时sleep方法会抛出InterruptedException
import lombok.extern.slf4j.Slf4j;

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

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                log.debug("enter sleep...");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    log.debug("wake up...");
                    e.printStackTrace();
                }
            }
        };
        t1.start();

        Thread.sleep(1000);
        log.debug("interrupt...");
        t1.interrupt();
    }
}
  1. 睡眠结束后的线程未必会立刻得到执行
  2. 建议用TimeUnit的sleep代替Thread的sleep获得更好的可读性
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;

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

    public static void main(String[] args) throws InterruptedException {
        log.debug("enter");
        TimeUnit.SECONDS.sleep(1);
        log.debug("end");
//        Thread.sleep(1000);
    }
}

yield

  • 调用yield会让当前Running进入Runnable就绪状态,然后调度执行其他线程
  • 具体的实现依赖于操作系统的任务调度器

线程优先级

  • 线程优先级会提示调度器优先调度该线程,但仅仅是一个提示,调度器可以忽略它
  • 如果cpu比较忙,那么优先级高的线程会获得更多的时间片,但cpu闲时,优先级几乎没作用
import lombok.extern.slf4j.Slf4j;

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

    public static void main(String[] args) {
        Runnable task1 = () -> {
            int count = 0;
            for (;;) {
                System.out.println("---->1 " + count++);
            }
        };
        Runnable task2 = () -> {
            int count = 0;
            for (;;) {
//                Thread.yield();
                System.out.println("              ---->2 " + count++);
            }
        };
        Thread t1 = new Thread(task1, "t1");
        Thread t2 = new Thread(task2, "t2");
//        t1.setPriority(Thread.MIN_PRIORITY);
//        t2.setPriority(Thread.MAX_PRIORITY);
        t1.start();
        t2.start();
    }
}

案例-防止cpu占用100%-sleep实现

在没有利用 cpu 来计算时,不要让 while(true) 空转浪费 cpu,这时可以使用 yield 或 sleep 来让出 cpu 的使用权 给其他程序

while(true) { 
    try {
        Thread.sleep(50);
    } catch (InterruptedException e) {
        e.printStackTrace(); 
    }
}
  • 可以用wait或条件变量达到类似的效果
  • 不同的是,后两种都需要加锁,并且需要相应的唤醒操作,一般适用于要进行同步的场景
  • sleep适用于无需锁同步的场景

join方法详解

为什么需要join

import lombok.extern.slf4j.Slf4j;

import static cn.itcast.n2.util.Sleeper.sleep;

@Slf4j(topic = "c.Test10")
public class Test10 {
    static int r = 0;
    public static void main(String[] args) throws InterruptedException {
        test1();
    }
    private static void test1() throws InterruptedException {
        log.debug("开始");
        Thread t1 = new Thread(() -> {
            log.debug("开始");
            sleep(1);
            log.debug("结束");
            r = 10;
        },"t1");
        t1.start();
        log.debug("结果为:{}", r);
        log.debug("结束");
    }
}

分析

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

解决方法

  • 用 sleep 行不行?为什么?可以,等待的时间不是很好确定

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

import lombok.extern.slf4j.Slf4j;

import static cn.itcast.n2.util.Sleeper.sleep;

@Slf4j(topic = "c.Test10")
public class Test10 {
    static int r = 0;
    public static void main(String[] args) throws InterruptedException {
        test1();
    }
    private static void test1() throws InterruptedException {
        log.debug("开始");
        Thread t1 = new Thread(() -> {
            log.debug("开始");
            sleep(1);
            log.debug("结束");
            r = 10;
        },"t1");
        t1.start();
        t1.join();
        log.debug("结果为:{}", r);
        log.debug("结束");
    }
}

等待多个结果

以调用方角度来讲,如果

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


//线程设置睡眠时间工具类
import java.util.concurrent.TimeUnit;

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

    public static void sleep(double i) {
        try {
            TimeUnit.MILLISECONDS.sleep((int) (i * 1000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;

import static cn.itcast.n2.util.Sleeper.sleep;

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

    public static void main(String[] args) throws InterruptedException {
        test2();
    }
    
    private static void test2() throws InterruptedException {
        //消耗时间取决于最长的线程t2
        Thread t1 = new Thread(() -> {
            sleep(1);
            r1 = 10;
        });
        Thread t2 = new Thread(() -> {
            sleep(2);
            r2 = 20;
        });
        t1.start();
        t2.start();
        long start = System.currentTimeMillis();
        log.debug("join begin");
        t2.join();
        log.debug("t2 join end");
        t1.join();
        log.debug("t1 join end");
        long end = System.currentTimeMillis();
        log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
    }
}

有时效的join

//如果线程在join的时效内完成了,主线程不会等待到join设置的时间才结束,会提前结束
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;

import static cn.itcast.n2.util.Sleeper.sleep;

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

    public static void main(String[] args) throws InterruptedException {
        test3();
    }

    public static void test3() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            sleep(2);
            r1 = 10;
        });

        long start = System.currentTimeMillis();
        t1.start();

        // 线程执行结束会导致 join 结束
        log.debug("join begin");
        t1.join(3000);
        long end = System.currentTimeMillis();
        log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
    }
}
//输出结果
12:16:22.464 c.TestJoin [main] - join begin
12:16:24.465 c.TestJoin [main] - r1: 10 r2: 0 cost: 2003

interrupt方法详解

打断sleep、wait、join的线程

这几个方法都会让线程进入阻塞状态,打断sleep、wait、join的线程,会清空打断状态(即线程.isInterrupted()返回false),以sleep为例:

import lombok.extern.slf4j.Slf4j;

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

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            log.debug("sleep...");
            try {
                Thread.sleep(5000); // wait, join
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t1");

        t1.start();
        Thread.sleep(500);
        log.debug("interrupt");
        t1.interrupt();
        log.debug("打断标记:{}", t1.isInterrupted());
    }
}
12:30:52.928 c.Test11 [t1] - sleep...
12:30:53.430 c.Test11 [main] - interrupt
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at cn.itcast.test.Test11.lambda$main$0(Test11.java:12)
    at java.lang.Thread.run(Thread.java:748)
12:30:53.431 c.Test11 [main] - 打断标记:false

打断正常运行的线程

打断正常运行的线程,不会清空打断状态

//打断只是提醒线程被打断了,需要线程自身去判断下一步采取什么操作
import lombok.extern.slf4j.Slf4j;

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

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            while(true) {
                boolean interrupted = Thread.currentThread().isInterrupted();
                if(interrupted) {
                    log.debug("被打断了, 退出循环");
                    break;
                }
            }
        }, "t1");
        t1.start();

        Thread.sleep(1000);
        log.debug("interrupt");
        t1.interrupt();
        log.debug("打断标记:{}", t1.isInterrupted());
    }
}
//输出,t1.interrupt();打断正常运行的线程,不会清除打断标记(即值为true)
16:16:41.259 c.Test12 [main] - interrupt
16:16:41.261 c.Test12 [t1] - 被打断了, 退出循环
16:16:41.261 c.Test12 [main] - 打断标记:true
终止模式之两阶段终止

Two Phase Termination

在一个线程T1中如何“优雅”终止线程T2?这里的优雅指的是给T2由处理最后必要操作的机会

  1. 错误思路
  • 使用线程对象的stop()方法停止线程:stop方法会真正杀死线程,如果这是线程锁住了共享资源,那么当它被杀死后就再也没有机会释放锁,其他线程将永远无法获取锁
  • 使用System.exit(int)方法停止线程:目的仅是停止了一个线程,但这种做法会让整个程序都停止
  1. 两阶段终止模式


    两阶段终止模式
  • 利用isInterrupted:interrupt可以打断正在执行的线程,
import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.TestTwoPhaseTermination")
public class TestTwoPhaseTermination {
    public static void main(String[] args) throws InterruptedException {
        TPTInterrupt tptInterrupt = new TPTInterrupt();
        tptInterrupt.start();
        Thread.sleep(3500);
        tptInterrupt.stop();
    }

}
@Slf4j(topic = "c.TPTInterrupt")
class TPTInterrupt {
    private Thread thread;

    public void start() {
        thread = new Thread(() -> {
            while (true) {
                Thread current = Thread.currentThread();
                if (current.isInterrupted()) {
                    log.debug("料理后事");
                    break;
                }
                try {
                    Thread.sleep(1000);//情况1,如果在这里打断,打断标记会被重置(即false),且会抛出InterruptedException
                    log.debug("将结果保存");//情况2,打断标记不会被刷新
                } catch (InterruptedException e) {
                  //情况1:是打断标记为true
                    current.interrupt();
                }
// 执行监控操作
            }
        }, "监控线程");
        thread.start();
    }

    public void stop() {
        thread.interrupt();
    }
}

打断park线程

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.locks.LockSupport;

import static cn.itcast.n2.util.Sleeper.sleep;

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

    private static void test4() {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                log.debug("park...");
                LockSupport.park();
                log.debug("打断状态:{}", Thread.interrupted());
            }
        });
        t1.start();


        sleep(1);
        t1.interrupt();
    }

    private static void test3() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            log.debug("park...");
            LockSupport.park();
            log.debug("unpark...");
            log.debug("打断状态:{}", Thread.currentThread().isInterrupted());
        }, "t1");
        t1.start();

        sleep(1);
        t1.interrupt();

    }

    public static void main(String[] args) throws InterruptedException {
        test3();
    }
}
//调用test4输出结果如下,并且程序一直被park住,因为当线程执行时,主线程在sleep,所以t1执行了循环中的语句,执行到LockSupport.park();,被park住,等主线程sleep完,执行了t1.interrupt();,打断标记为true,park停止,继续执行log.debug("打断状态:{}", Thread.interrupted());,但是Thread.interrupted()会清除打断标记(即重置为false)所以继续执行第2次循环时就一直被park住了,因为主线程已经执行结束,所以控制台会一直运行
15:04:05.879 c.Test14 [Thread-0] - park...
15:04:06.882 c.Test14 [Thread-0] - 打断状态:true
15:04:06.884 c.Test14 [Thread-0] - park...
//调用test3输出结果如下,线程t1启动,主线程sleep,t1执行了log.debug("park...");和LockSupport.park();,此时被park住,等主线程sleep完,执行t1.interrupt();,此时打断标记为true,t1线程不会被park了,继续执行park后面的代码
15:09:15.833 c.Test14 [t1] - park...
15:09:16.837 c.Test14 [t1] - unpark...
15:09:16.838 c.Test14 [t1] - 打断状态:true

不推荐的方法

还有一些不推荐使用的方法,这些方法已过时,容易破坏同步代码块,造成线程死锁

方法名 static 功能说明
stop() 停止线程运行
suspend() 挂起(暂停)线程运行
resume() 恢复线程运行

主线程与守护线程

默认情况下,Java进程需要等待所有线程都运行结束,才能结束。有一种特殊的线程叫做守护线程,只能其他非守护线程运行结束了,即使守护线程的代码没有执行完,也会强制结束。

log.debug("开始运行..."); 
Thread t1 = new Thread(() -> {
    log.debug("开始运行..."); 
  sleep(2); 
  log.debug("运行结束...");
}, "daemon");
// 设置该线程为守护线程 t1.setDaemon(true); t1.start();
sleep(1); 
log.debug("运行结束...");
//输出
 08:26:38.123 [main] c.TestDaemon - 开始运行... 08:26:38.213 [daemon] c.TestDaemon - 开始运行... 08:26:39.215 [main] c.TestDaemon - 运行结束...
注意
垃圾回收器线程就是一种守护线程
Tomcat中的Acceptor和Poller线程都是守护线程,所以Tomcat接收到shutdown命令后,不会等待它们处理完当前请求

操作系统-五种状态

这是从操作系统层面来描述的


操作系统五种状态
  • 【初始状态】仅是在语言层面创建了线程对象,还未与操作系统线程关联
  • 【可运行状态】(就绪状态)指该线程已经被创建(与操作系统线程关联),可以由cpu调度执行
  • 【运行状态】指获取了cpu时间片运行中的状态
    • 如果调用了阻塞api,如BIO读写文件,这是该线程实际不会用到cpu,会导致线程上下文切换,进入【阻塞状态】
    • 等BIO操作完毕,会由操作系统唤醒阻塞的线程,转换至【可运行状态】
    • 与【可运行状态】的区别是,对【阻塞状态】的线程来说只要它们一直不唤醒,调度器就一直不会考虑调度它们
  • 【终止状态】表示线程已经执行完毕,生命周期已经结束,不会再转换为其他状态

Java-六种状态

这是从Java API层面来描述的,根据Thread.state枚举,分为六种状态


Java六种状态
  • NEW线程刚被创建,但是还没有调用start()方法
  • RUNNABLE 当调用了start()方法之后,注意Java API层面的RUNNABLE状态涵盖了操作系统层面的【可运行状态】【运行状态】和【阻塞状态】(由于BIO导致的线程阻塞,在Java里无法区分,仍然认为是可运行)
  • BLOCKED、WAITING、TIMED_WAITING都是Java API层面对【阻塞状态】的细分,后面会在状态转换一节详述
  • TERMINATED当线程代码运行结束
import lombok.extern.slf4j.Slf4j;

import java.io.IOException;

@Slf4j(topic = "c.TestState")
public class TestState {
    public static void main(String[] args) throws IOException {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                log.debug("running...");
            }
        };

        Thread t2 = new Thread("t2") {
            @Override
            public void run() {
                while(true) { // runnable

                }
            }
        };
        t2.start();

        Thread t3 = new Thread("t3") {
            @Override
            public void run() {
                log.debug("running...");
            }
        };
        t3.start();

        Thread t4 = new Thread("t4") {
            @Override
            public void run() {
                synchronized (TestState.class) {
                    try {
                        Thread.sleep(1000000); // timed_waiting
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t4.start();

        Thread t5 = new Thread("t5") {
            @Override
            public void run() {
                try {
                    t2.join(); // waiting
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        t5.start();

        Thread t6 = new Thread("t6") {
            @Override
            public void run() {
                synchronized (TestState.class) { // blocked
                    try {
                        Thread.sleep(1000000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t6.start();

        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("t1 state {}", t1.getState());
        log.debug("t2 state {}", t2.getState());
        log.debug("t3 state {}", t3.getState());
        log.debug("t4 state {}", t4.getState());
        log.debug("t5 state {}", t5.getState());
        log.debug("t6 state {}", t6.getState());
        System.in.read();
    }
}
18:00:50.466 c.TestState [t3] - running...
18:00:50.970 c.TestState [main] - t1 state NEW
18:00:50.972 c.TestState [main] - t2 state RUNNABLE
18:00:50.972 c.TestState [main] - t3 state TERMINATED
18:00:50.972 c.TestState [main] - t4 state TIMED_WAITING
18:00:50.972 c.TestState [main] - t5 state WAITING
18:00:50.972 c.TestState [main] - t6 state BLOCKED

习题

阅读华罗庚《统筹方法》,给出烧水泡茶的多线程解决方案,提示

  • 参考图二,用两个线程(两个人协作)模拟烧水泡茶过程:文中办法乙、丙都相当于任务串行;而图一相当于启动了 4 个线程,有点浪费
  • 用 sleep(n) 模拟洗茶壶、洗水壶等耗费的时间
华罗庚《统筹方法》
统筹方法,是一种安排工作进程的数学方法。它的实用范围极广泛,在企业管理和基本建设中,以及关系复 杂的科研项目的组织与管理中,都可以应用。
怎样应用呢?主要是把工序安排好。
比如,想泡壶茶喝。当时的情况是:开水没有;水壶要洗,茶壶、茶杯要洗;火已生了,茶叶也有了。怎么 办?
办法甲:洗好水壶,灌上凉水,放在火上;在等待水开的时间里,洗茶壶、洗茶杯、拿茶叶;等水开 了,泡茶喝。 办法乙:先做好一些准备工作,洗水壶,洗茶壶茶杯,拿茶叶;一切就绪,灌水烧水;坐待水开了,泡 茶喝。 办法丙:洗净水壶,灌上凉水,放在火上,坐待水开;水开了之后,急急忙忙找茶叶,洗茶壶茶杯,泡 茶喝。
哪一种办法省时间?我们能一眼看出,第一种办法好,后两种办法都窝了工。 这是小事,但这是引子,可以引出生产管理等方面有用的方法来。
水壶不洗,不能烧开水,因而洗水壶是烧开水的前提。没开水、没茶叶、不洗茶壶茶杯,就不能泡茶,因而 这些又是泡茶的前提。它们的相互关系,可以用下边的箭头图来表示:
图一
从这个图上可以一眼看出,办法甲总共要16分钟(而办法乙、丙需要20分钟)。如果要缩短工时、提高工作 效率,应当主要抓烧开水这个环节,而不是抓拿茶叶等环节。同时,洗茶壶茶杯、拿茶叶总共不过4分钟,大 可利用“等水开”的时间来做。
是的,这好像是废话,卑之无甚高论。有如走路要用两条腿走,吃饭要一口一口吃,这些道理谁都懂得。但 稍有变化,临事而迷的情况,常常是存在的。在近代工业的错综复杂的工艺过程中,往往就不是像泡茶喝这 么简单了。任务多了,几百几千,甚至有好几万个任务。关系多了,错综复杂,千头万绪,往往出现“万事俱 备,只欠东风”的情况。由于一两个零件没完成,耽误了一台复杂机器的出厂时间。或往往因为抓的不是关 键,连夜三班,急急忙忙,完成这一环节之后,还得等待旁的环节才能装配。
洗茶壶,洗茶杯,拿茶叶,或先或后,关系不大,而且同是一个人的活儿,因而可以合并成为:
图二

看来这是“小题大做”,但在工作环节太多的时候,这样做就非常必要了。 这里讲的主要是时间方面的事,但在具体生产实践中,还有其他方面的许多事。这种方法虽然不一定能直接
解决所有问题,但是,我们利用这种方法来考虑问题,也是不无裨益的。

应用之统筹(烧水泡茶)

解法1:join
import lombok.extern.slf4j.Slf4j;

import static cn.itcast.n2.util.Sleeper.sleep;

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


    public static void main(String[] args) {
        s1();
    }

    private static void s1() {
        Thread t1 = new Thread(() -> {
            log.debug("洗水壶");
            sleep(1);
            log.debug("烧开水");
            sleep(15);
        }, "老王");

        Thread t2 = new Thread(() -> {
            log.debug("洗茶壶");
            sleep(1);
            log.debug("洗茶杯");
            sleep(2);
            log.debug("拿茶叶");
            sleep(1);
            try {
                t1.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.debug("泡茶");
        }, "小王");

        t1.start();
        t2.start();
    }
}
//输出
 19:19:37.547 [小王] c.TestMakeTea - 洗茶壶 
 19:19:37.547 [老王] c.TestMakeTea - 洗水壶 
 19:19:38.552 [小王] c.TestMakeTea - 洗茶杯 
 19:19:38.552 [老王] c.TestMakeTea - 烧开水 
 19:19:40.553 [小王] c.TestMakeTea - 拿茶叶 
 19:19:53.553 [小王] c.TestMakeTea - 泡茶
//解法1缺陷
上面模拟的是小王等老王的水烧开了,小王泡茶,如果反过来要实现老王等小王的茶叶拿来了,老王泡茶呢?代码最好能适应两种情况 上面的两个线程其实是各执行各的,如果要模拟老王把水壶交给小王泡茶,或模拟小王把茶叶交给老王泡茶呢

本章小结

  • 线程创建
  • 线程重要api,如start、run、sleep、join、interrupt等
  • 线程状态:操作系统五种,java六种
  • 应用方面
    • 异步调用:主线程执行期间,其他线程异步执行耗时操作
    • 提高效率:并行计算,缩短运算时间
    • 同步等待:join
    • 统筹规划:合理使用线程,得到最优结果
  • 原理方面
    • 线程运行流程:栈、栈帧、上下文切换、程序计数器
    • Thread两种创建方式的源码
  • 模式方面
    • 终止模式之两阶段终止

你可能感兴趣的:(3、并发编程-Java线程)