深入浅出剖析JAVA多线程原理_java线程之间得切换原理、

常用的参数：
-u 默认参数，显示各个进程的 CPU 统计信息
-r 显示各个进程的内存使用情况
-d 显示各个进程的 IO 使用
-w 显示各个进程的上下文切换
-p PID 指定 PID
 
# 显示进程5598每一秒的切换情况
pidstat -w -p 5598 1

public void test() {
    Thread newThread = new Thread() {
        @Override
            public void run() {
            System.out.println("new Thread");
        }
    };
 
    MyThread myThread = new MyThread();
 
    newThread.start();
    myThread.start();
}
 
class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("extend Thread");
    }
}

public void test2() {
    Runnable runnable = new Runnable() {
 
        @Override
            public void run() {
            System.out.println("implement runnable");
        }
    };
 
    Thread thread = new Thread(runnable);
    thread.start();
}

public void test3() {
    ExecutorService executorService = Executors.newFixedThreadPool(10);
    Future<Integer> submit = executorService.submit(new MyCallableTask());
    try {
        System.out.println(submit.get());
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }
    executorService.shutdown();
}

class MyCallableTask implements Callable<Integer> {
 
    @Override
    public Integer call() throws Exception {
        return new Random().nextInt();
    }
}

public void test4() {
    FutureTask<String> task = new FutureTask<>(new Callable<String>() {
        @Override
        public String call() throws Exception {
            return "callable";
        }
    });
 
    new Thread(task).start();
 
    try {
        String s = task.get();
        System.out.println(s);
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }
}

new Thread(() -> System.out.println(Thread.currentThread().getName())).start();

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

public Thread newThread(Runnable r) {
    Thread t = new Thread(group, r,
                          namePrefix + threadNumber.getAndIncrement(),
                          0);
    if (t.isDaemon())
        t.setDaemon(false);
    if (t.getPriority() != Thread.NORM_PRIORITY)
        t.setPriority(Thread.NORM_PRIORITY);
    return t;
}

协程
协程，英文Coroutines, 是一种基于线程之上，但又比线程更加轻量级的存在，协程不是被操作系统内核所管理，而完全是由程序所控制（也就是在用户态执行），具有对内核来说不可见的特性。
这样带来的好处就是性能得到了很大的提升，不会像线程切换那样消耗资源。

子程序，或者称为函数，在所有语言中都是层级调用，比如A调用B，B在执行过程中又调用了C，C执行完毕返回，B执行完毕返回，最后是A执行完毕。而协程的调用和子程序不同。协程在子程序内部是可中断的，然后转而执行别的子程序，在适当的时候再返回来接着执行。

Java

def A():
    print '1'
    print '2'
    print '3'
def B():
    print 'x'
    print 'y'
    print 'z'

假设由协程执行，在执行A的过程中，可以随时中断，去执行B，B也可能在执行过程中中断再去执行A，结果可能是：1 2 x y 3 z。
协程的特点在于是一个线程执行。
协程优势
        ●线程的切换由操作系统调度，协程由用户自己进行调度，因此减少了上下文切换，提高了效率。
        ●线程的默认stack大小是1M，而协程更轻量，接近1k。因此可以在相同的内存中开启更多的协程。
        ●不需要多线程的锁机制：因为只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不加锁，只需要判断状态就好了，所以执行效率比多线程高很多。
协程适用于被阻塞的，且需要大量并发的场景（网络io）。不适合大量计算的场景。

Java中的协程框架
kilim quasar

2.3 Java线程的调度机制

线程调度是指系统为线程分配处理器使用权的过程，主要调度方式分两种，分别是协同式线程调度和抢占式线程调度

协同式线程调度

线程执行时间由线程决定。线程把自己的任务执行完毕后，要主动通知系统切换到另外一个线程上。
好处：
        1实现简单，上下文切换对线程来说是可见的
        2没有线程同步问题
坏处：
        1执行时间不可控。如果某个线程发生阻塞，CPU可能一直阻塞。
抢占式线程调度
由操作系统为每个线程分配执行时间片，线程切换有OS决定。 好处：
1线程执行时间可控，不会因为一个线程阻塞导致整个CPU阻塞。

Java线程的抢占式线程调度体现

希望系统能给某些线程多分配一些时间，给一些线程少分配一些时间，可以通过设置线程优先级来完成。Java语言一共10个级别的线程优先级（Thread.MIN_PRIORITY至Thread.MAX_PRIORITY），在两线程同时处于ready状态时，优先级越高的线程越容易被系统选择执行。但优先级并不是很靠谱，因为Java线程是通过映射到系统的原生线程上来实现的，所以线程调度最终还是取决于操作系统。

2.4 Java线程生命周期

Java 语言中线程共有六种状态，分别是：
1NEW（初始化状态）
2RUNNABLE（可运行状态+运行状态）
3BLOCKED（阻塞状态）
4WAITING（无时限等待）
5TIMED_WAITING（有时限等待）
6TERMINATED（终止状态）
在操作系统层面，Java 线程中的 BLOCKED、WAITING、TIMED_WAITING 是一种状态，即前面我们提到的休眠状态。也就是说只要 Java 线程处于这三种状态之一，那么这个线程就永远没有 CPU 的使用权。

yield不会像park、wait、join等操作，涉及到上下文切换等重量级操作，很快可以被再次执行。

从JavaThread的角度，JVM定义了一些针对Java Thread对象的状态（jvm.h）

*/

从OSThread的角度，JVM还定义了一些线程状态给外部使用，比如用jstack输出的线程堆栈信息中线程的状态（osThread.hpp）

2.5 Thread常用方法

sleep

• 调用 sleep 会让当前线程从 Running 进入TIMED_WAITING状态，不会释放对象锁
• 其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException，并且会清除中断标志
• 睡眠结束后的线程未必会立刻得到执行
• sleep当传入参数为0时，和yield相同

yield

• yield会释放CPU资源，让当前线程从 Running 进入 Runnable状态，让优先级更高（至少是相同）的线程获得执行机会，不会释放对象锁；
• 假设当前进程只有main线程，当调用yield之后，main线程会继续运行，因为没有比它优先级更高的线程；
• 具体的实现依赖于操作系统的任务调度器

join

等待调用join方法的线程结束之后，程序再继续执行，一般用于等待异步线程执行完结果之后才能继续运行的场景。

public class ThreadJoinDemo {
    public static void main(String[] sure) throws InterruptedException {
 
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("t begin");
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t finished");
            }
        });
        long start = System.currentTimeMillis();
        t.start();
        //主线程等待线程t执行完成
        t.join();
 
        System.out.println("执行时间:" + (System.currentTimeMillis() - start));
        System.out.println("Main finished");
    }
}

stop

stop()方法已经被jdk废弃，原因就是stop()方法太过于暴力，强行把执行到一半的线程终止。

这种方式会释放对象锁，导致线程执行到一半被强制结束，可能导致数据的不一致性。

public class ThreadStopDemo {
    private static Object lock = new Object();
 
    public static void main(String[] args) throws InterruptedException {
 
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    System.out.println(Thread.currentThread().getName() + "获取锁");
                    try {
                        Thread.sleep(60000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName() + "执行完成");
            }
        });
        thread.start();
        Thread.sleep(2000);
        // 停止thread，并释放锁
        thread.stop();
 
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "等待获取锁");
                synchronized (lock) {
                    System.out.println(Thread.currentThread().getName() + "获取锁");
                }
            }
        }).start();
 
    }
}

如何优雅的停止线程？

Java提供了中断机制去优雅的停止线程，见下面。

2.6 Java线程的中断机制

Java没有提供一种安全、直接的方法来停止某个线程，而是提供了中断机制。中断机制是一种协作机制，也就是说通过中断并不能直接终止另一个线程，而需要被中断的线程自己处理。被中断的线程拥有完全的自主权，它既可以选择立即停止，也可以选择一段时间后停止，也可以选择压根不停止。

简单来说，A线程运行过程中，要去中断B线程，会为B线程设置一个标记，B线程代码实现中，可以有针对于标记的检查点，当发现标志位表示中断时，B线程调用自己的代码逻辑去处理中断请求，比如可以停止自己、或者忽视。

API使用

• interrupt()： 将线程的中断标志位设置为true，不会停止线程
• isInterrupted(): 判断当前线程的中断标志位是否为true，不会清除中断标志位
• Thread.interrupted()：判断当前线程的中断标志位是否为true，并清除中断标志位，重置为fasle

使用中断机制时一定要注意是否存在中断标志位被清除的情况，即认真区分下面的两种情况：

测试isInterrupted()

public class ThreadInterruptTest {
    static int i = 0;
 
    public static void main(String[] args) {
        System.out.println("begin");
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    i++;
                    System.out.println(i);
                    //Thread.interrupted()  清除中断标志位
                    //Thread.currentThread().isInterrupted() 不会清除中断标志位
                    if (Thread.currentThread().isInterrupted()) {
                        System.out.println("=========");
                    }
                    if (i == 10) {
                        break;
                    }
 
                }
            }
        });
 
        t1.start();
        //不会停止线程t1,只会设置一个中断标志位 flag=true
        t1.interrupt();
    }
}

测试Thread.interrupted()

public class ThreadInterruptTest {
    static int i = 0;
 
    public static void main(String[] args) {
        System.out.println("begin");
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    i++;
                    System.out.println(i);
                    //Thread.interrupted()  清除中断标志位
                    //Thread.currentThread().isInterrupted() 不会清除中断标志位
                    if (Thread.interrupted()) {
                        System.out.println("=========");
                    }
                    if (i == 10) {
                        break;
                    }
 
                }
            }
        });
 
        t1.start();
        //不会停止线程t1,只会设置一个中断标志位 flag=true
        t1.interrupt();
    }
}

利用中断机制优雅的停止线程

while (!Thread.currentThread().isInterrupted() && more work to do) {
    do more work
}

public class StopThread implements Runnable {
 
    @Override
    public void run() {
        int count = 0;
        while (!Thread.currentThread().isInterrupted() && count < 1000) {
            System.out.println("count = " + count++);
        }
        System.out.println("线程停止： stop thread");
    }
 
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new StopThread());
        thread.start();
        Thread.sleep(5);
        thread.interrupt();
    }
}

sleep期间能否感到中断

@Override
public void run() {
    int count = 0;
    while (!Thread.currentThread().isInterrupted() && count < 1000) {
        System.out.println("count = " + count++);
 
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    System.out.println("线程停止： stop thread");
}

处于休眠中的线程被中断，线程是可以感受到中断信号的，并且会抛出一个 InterruptedException 异常，同时清除中断信号，将中断标记位设置成 false。这样就会导致while条件Thread.currentThread().isInterrupted()为false，程序会在不满足count < 1000这个条件时退出。如果不在catch中重新手动添加中断信号，不做任何处理，就会屏蔽中断请求，有可能导致线程无法正确停止。

try {
    Thread.sleep(1);
} catch (InterruptedException e) {
    e.printStackTrace();
    //重新设置线程中断状态为true
    Thread.currentThread().interrupt();
}

总结

sleep可以被中断 抛出中断异常：sleep interrupted， 清除中断标志位

wait可以被中断 抛出中断异常：InterruptedException， 清除中断标志位

2.7 Java线程间通信

volatile

volatile有两大特性，一是可见性，二是有序性，禁止指令重排序，其中可见性就是可以让线程之间进行通信。

public class VolatileTest {
    private static volatile boolean flag = true;
 
    public static void main(String[] args) {
 
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    if (flag) {
                        System.out.println("trun on");
                        flag = false;
                    }
                }
            }
        }).start();
 
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    if (!flag) {
                        System.out.println("trun off");
                        flag = true;
                    }
                }
            }
        }).start();
    }
}

等待唤醒机制/等待通知机制

等待唤醒机制可以基于wait和notify方法来实现，在一个线程内调用该线程锁对象的wait方法，线程将进入等待队列进行等待直到被唤醒。

public class WaitDemo {
    private static Object lock = new Object();
    private static boolean flag = true;
 
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    while (flag) {
                        try {
                            System.out.println("wait start .......");
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
 
                    System.out.println("wait end ....... ");
                }
            }
        }).start();
 
        new Thread(new Runnable() {
            @Override
            public void run() {
                if (flag) {
                    synchronized (lock) {
                        if (flag) {
                            lock.notify();
                            System.out.println("notify .......");
                            flag = false;
                        }
 
                    }
                }
            }
        }).start();
    }
}

LockSupport是JDK中用来实现线程阻塞和唤醒的工具，具有如下特点：

• 线程调用park则等待“许可”，调用unpark则为指定线程提供“许可”。
• 使用它可以在任何场合使线程阻塞，可以指定任何线程进行唤醒，并且不用担心阻塞和唤醒操作的顺序，但要注意连续多次唤醒的效果和一次唤醒是一样的。

public class LockSupportTest {
 
    public static void main(String[] args) {
        Thread parkThread = new Thread(new ParkThread());
        parkThread.start();
 
        System.out.println("唤醒parkThread");
        LockSupport.unpark(parkThread);
    }
 
    static class ParkThread implements Runnable{
 
        @Override
        public void run() {
            System.out.println("ParkThread开始执行");
            LockSupport.park();
            System.out.println("ParkThread执行完成");
        }
    }
}

管道输入输出流

管道输入/输出流和普通的文件输入/输出流或者网络输入/输出流不同之处在于，它主要用于线程之间的数据传输，而传输的媒介为内存。管道输入/输出流主要包括了如下4种具体实现：

• 面向字节
  PipedOutputStream、PipedInputStream
• 面向字符
  PipedReader、PipedWriter

public class Piped {
    public static void main(String[] args) throws Exception {
        PipedWriter out = new PipedWriter();
        PipedReader in = new PipedReader();
        // 将输出流和输入流进行连接，否则在使用时会抛出IOException
        out.connect(in);
 
        Thread printThread = new Thread(new Print(in), "PrintThread");
 
        printThread.start();
        int receive = 0;
        try {
            while ((receive = System.in.read()) != -1) {
                out.write(receive);
            }
        } finally {
            out.close();
        }
    }
 
    static class Print implements Runnable {
        private PipedReader in;
 
        public Print(PipedReader in) {
            this.in = in;
        }
 
        @Override
        public void run() {
            int receive = 0;
            try {
                while ((receive = in.read()) != -1) {
                    System.out.print((char) receive);
                }
            } catch (IOException ex) {
            }
        }
    }
}

Thread#join()

join可以理解成是线程合并，当在一个线程调用另一个线程的join方法时，当前线程阻塞等待被调用join方法的线程执行完毕才能继续执行，所以join的好处能够保证线程的执行顺序，但是如果调用线程的join方法其实已经失去了并行的意义，虽然存在多个线程，但是本质上还是串行的，最后join的实现其实是基于等待通知机制的。