Java多线程初识

初识多线程

线程是操作系统中CPU运行调度的最小单位，一个进程包含多个线程，每个线程可以执行不同的任务。并发执行可以让程序运行得更快

多线程下的并行、并发

并行

指同一个的时间中，同时执行的线程(两个或以上)。
例如：一台机器需要花10分钟才可以执行完成的任务，两台机器可以拆分任务那么就只需要各5分钟在同一时刻就可以完成，这就代表并行。
注：一个机器可以理解为一个单核的CPU，那么并行就需要多核CPU

并发

多个线程同时请求执行任务，但是在这段时间内就只可以执行一个线程，然而CPU拥有很快的速度，通过切换CPU的调度时间片，就感觉是同时执行完成，实际为交叉执行。
例如：两条同方向的汽车行驶道路，在前方需要合并成单条行驶道路

多线程异步、同步

多线程的同步

多个线程同时访问一个公共资源时，同一时刻只可以有一个线程A执行获得CPU的执行调度时间片，而其他线程需要等待线程A执行完后才可以由另一个执行
优点：没有多线程下的并发安全问题
缺点：执行效能慢

多线程的异步

多个线程可以一起执行不同/相同的任务，可以理解为同一时刻可以各干各的事，
可以结果现实中的现象理解：如点外卖，小明通过App操作下单后，由外卖小哥去店铺取货，然后送到客户地址，在取货和送货这段时间内小明是可以做其他事，不用等外卖小哥。
优点：提高执行效率
缺点：存在并发线程安全问题

线程的状态

代码详情

public class StatThread implements Runnable{
    @Override
    public void run() {
        synchronized (StatThread.class){
            while (true){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            try {
                Thread.sleep(4000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"TIME_SLEEP").start();
        new Thread(()->{
            synchronized (StatThread.class){
                try {
                    StatThread.class.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"WAIT").start();
        new Thread(new StatThread(),"BLOCKE_1").start();
        new Thread(new StatThread(),"BLOCKE_2").start();
        Thread.sleep(3000);
        System.out.println("main线程执行完成");
    }
}

堆栈信息

查询运行时的堆栈信息 jstack 运行时的进程ID(jps)

“BLOCKE_2” #15 prio=5 os_prio=0 tid=0x000000001b3c2000 nid=0x250c waiting for monitor entry [0x000000001be8f000]
java.lang.Thread.State: BLOCKED (on object monitor)
at comyiji.thread.day1.StatThread.run(StatThread.java:12)
- waiting to lock <0x00000000d6154f98> (a java.lang.Class for comyiji.thread.day1.StatThread)
at java.lang.Thread.run(Thread.java:748)

“BLOCKE_1” #14 prio=5 os_prio=0 tid=0x000000001b3c1800 nid=0x2e34 waiting on condition [0x000000001bd8f000]
java.lang.Thread.State: TIMED_WAITING (sleeping)
at java.lang.Thread.sleep(Native Method)
at comyiji.thread.day1.StatThread.run(StatThread.java:12)
- locked <0x00000000d6154f98> (a java.lang.Class for comyiji.thread.day1.StatThread)
at java.lang.Thread.run(Thread.java:748)

“WAIT” #13 prio=5 os_prio=0 tid=0x000000001b3c0800 nid=0x3008 in Object.wait() [0x000000001bc8f000]
java.lang.Thread.State: WAITING (on object monitor)
at java.lang.Object.wait(Native Method)
- waiting on <0x00000000d6154f98> (a java.lang.Class for comyiji.thread.day1.StatThread)
at java.lang.Object.wait(Object.java:502)
at comyiji.thread.day1.StatThread.lambda$main$1(StatThread.java:30)-locked<0x00000000d6154f98>(ajava.lang.Classforcomyiji.thread.day1.StatThread)atcomyiji.thread.day1.StatThread$$Lambda$2/521645586.run(Unknown Source)
at java.lang.Thread.run(Thread.java:748)

“TIME_SLEEP” #12 prio=5 os_prio=0 tid=0x000000001b3c0000 nid=0xcf0 waiting on condition [0x000000001bb8f000]
java.lang.Thread.State: TIMED_WAITING (sleeping)
at java.lang.Thread.sleep(Native Method)
at java.lang.Thread.sleep(Thread.java:340)
at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
at comyiji.thread.day1.StatThread.lambda$main$0(StatThread.java:22)atcomyiji.thread.day1.StatThread$$Lambda$1/1702297201.run(Unknown Source)
at java.lang.Thread.run(Thread.java:748)

总结Java中的状态

六种状态

• NEW：未启动的线程状态，还未调用start()方法
• RUNNABLE：运行状态，可在JVM虚拟机中执行
• BLOCKED:阻塞状态，线程进入阻塞等待，监视锁的线程状态，失去CPU执行时间片
• WAIT：等待状态。当前线程执行了wait()、join()、LockSupport.park()
• TIMED_WAITING:有时间的控制等待，超过控制时间自动返回，不会释放锁，Thread.sleep(TimeUnit)
• TERMINATED：终止状态，线程执行结束

线程的友好中断 (interrupt)

interrupet();是JDK中natice类型的方法，具体是在JVM中实现线程中断信号flag

@Override
    public void run() {
        synchronized (ThreadEnd2.class){
            while (!Thread.currentThread().isInterrupted()){
                try {
                    System.out.println("ThreadEndSleep-begin");
                    Thread.sleep(1000);
                    System.out.println("ThreadEndSleep-end");
                } catch (InterruptedException e) {//捕获触发中断信号通知A后，会将interrupt复位，也就是interrupt重新修改为了false
                    //具体是否结实线程由run方法内部决定，
                    System.out.println("printStackTrace-ExceptionBegin");
                    e.printStackTrace();
                    Thread.currentThread().interrupt();//又触发了中断信息，修改 interrupt = true
                    //修改将interrupt = true以下代码还是会执行，下次循环终止
                    //!Thread.currentThread().isInterrupted() == false
                    System.out.println("printStackTrace-ExceptionEnd");
                }
                System.out.println("Thread-Name:"+Thread.currentThread().getName());
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread threadEnd2 = new Thread(new ThreadEnd2(), "ThreadEnd");
        threadEnd2.start();
        Thread.sleep(2000);
        System.out.println("interrupt-begin");
        //interrupt开始falg默认返回false
        threadEnd2.interrupt();//触发中断信号通知A，将interrupt 修改为true
        System.out.println("interrupt-end");
    }