Java并发概念和基础

• 进程与线程
• • 进程
  • 线程
  • 进程与线程的区别
• 并行与并发
• • 并发
  • 并行
• 同步和异步
• Java创建线程
• • 继承Thread类
  • 实现Runnable接口
  • 使用FuntureTash类配合Thread
  • 使用线程池，后面会专门讲解
• 线程上下文切换
• Thread常见方法
• • start 与 run
  • sleep与yield
  • 线程优先级
  • join
  • interrupt方法详解
• 线程状态
• • 操作系统层面的五种线程状态
  • Java的六种状态

进程与线程

进程

• 程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至 CPU，数据加载至内存。在指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存、管理 IO 的
• 进程是系统分配资源的最小单元

线程

• 一个进程可以有多个线程
• 线程是cpu调度的基本单位，线程之间共享进程资源

进程与线程的区别

• 进程的独立的，而线程存在于进程内，是进程的一个子集
• 进程拥有共享的资源，供内部的线程共享

并行与并发

并发

单核 cpu 下，线程实际还是 串行执行 的。操作系统中有一个组件叫做任务调度器，将 cpu 的时间片（windows下时间片最小约为 15 毫秒）分给不同的程序使用，只是由于 cpu 在线程间（时间片很短的）切换非常快，人类感觉是同时运行的 。总结为一句话就是： 微观串行，宏观并行
一般将这种现场轮流使用CPU的做法叫做并发，concurrent

并行

简单来说，并发就是一段时间内，我干完这个，再去干那个，相当于一段时间内一个人干多件事情。而并行就是在某一个时间，我同时干了多件事，比如说我一边洗脚一边打王者荣耀。在现在的多CPU处理器下，并发和并行一般是同时存在的

同步和异步

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

同步就相当于是 当客户端发送请求给服务端，在等待服务端响应的请求时，客户端不做其他的事情。当服务端做完了才返回到客户端。这样的话客户端需要一直等待。用户使用起来会有不友好。
异步就是，当客户端发送给服务端请求时，在等待服务端响应的时候，客户端可以做其他的事情，这样节约了时间，提高了效率。
存在就有其道理 异步虽然好 但是有些问题是要用同步用来解决，比如有些东西我们需要的是拿到返回的数据再进行操作的。这些是异步所无法解决的。

Java创建线程

继承Thread类

 //继承Thread类，重写run方法 new Thread("A"){     @Override     public void run() {  System.out.println(Thread.currentThread().getName());     } }.start();

实现Runnable接口

 //实现runnable接口 new Thread(new Runnable() {     @Override     public void run() {  System.out.println(Thread.currentThread().getName());     } },"B").start(); //lamba表达式简化 new Thread(()->{     System.out.println(Thread.currentThread().getName()); },"C").start();

使用FuntureTash类配合Thread

 //使用FutureTash类 FutureTask<Integer> task=new FutureTask<>(new Callable<Integer>() {     @Override     public Integer call() throws Exception {  return 100;     } }); new Thread(task,"D").start(); System.out.println(task.get());

使用线程池，后面会专门讲解

线程上下文切换

因为以下一些原因导致CPU不再执行当前线程，转而执行其他线程

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

当上下文切换发生时，操作系统需要保存当前线程的状态，恢复执行线程的状态。Java中对应的概念为程序计数器，它的作用是记住下一条jvm指令的执行地址，是线程私有的。
频繁上下文切换会降低性能

Thread常见方法

start 与 run

我们尝试使用run或者start来开启线程

 new Thread("A"){     @Override     public void run() {  System.out.println(Thread.currentThread().getName()+"    runing....");     } }.run(); new Thread("B"){     @Override     public void run() {  System.out.println(Thread.currentThread().getName()+"    runing....");     } }.start();

main    runing....B    runing....Process finished with exit code 0

上面发现：直接调用run只是调用类的一个普通方法，并没有开启多线程。只有调用了start方法才开启了多线程。
查看源码


这里调用run方法只是调用了Runnable接口里的方法，相当于我们只是main线程调用了一个普通方法而已。

而调用我们的start方法后，最后会执行start0()这个本地方法，由JVM来创建一个线程，这时该线程处于就绪状态(NEW)，并没有运行。当该线程分得CPU时间段后，会调用run方法执行。此时进入了运行状态

sleep与yield

sleep：

• 调用sleep会使线程从Runnig状态进入time_waiting状态
• 睡眠过后的线程会进入到就绪态，不一定会马上执行

yield：

• 调用yield会使线程从Runnig状态进入Runable状态，然后尝试调用其他线程

线程优先级

设置较高的线程优先级会使调度器优先调度该线程，但只是一个提示，可能调度器并不会理会它

join

    static int r = 0;    public static void main(String[] args) throws InterruptedException { test1();    }    private static void test1() throws InterruptedException { System.out.println("开始"); Thread t1 = new Thread(() -> {     System.out.println("开始");     try {  sleep(1);     } catch (InterruptedException e) {  throw new RuntimeException(e);     }     System.out.println("结束");     r = 10; }); t1.start(); System.out.println("结果为:"+ r); System.out.println("结束");    }

因为t1和t2线程是并行执行的，而t1需要等待1s才能算出r。所以只能打印出r=0
解决方法：加sleep行不行？？不行，因为有可能t1的执行时间很长，不能够准确判断什么时候执行完毕。加t1.join在t1.start()之后便可以，这样便可以等待t1运行完才执行后面的线程了

带时间参数的join，等待指定时间后，最多等待指定时间就必须执行了

interrupt方法详解

    public static void main(String[] args) throws InterruptedException { Thread x=new Thread(()->{     try {  sleep(4000);     } catch (InterruptedException e) {  throw new RuntimeException(e);     } },"A"); x.start(); x.interrupt(); System.out.println(x.isInterrupted());    }

打断 sleep，wait，join 的线程
这几个方法都会让线程进入阻塞状态
打断 sleep，wait，join 的线程, 会清空打断状态;
打断正常运行的线程, 不会清空打断状态

线程状态

操作系统层面的五种线程状态

Java的六种状态