并发与并行：

  • 并发是关于正确有效地控制对共享资源的访问。
  • 并行是使用额外的资源来更快地产生结果。

并发一段时间内多个程序可运行，一个CPU即可。

并行一个时间点内多个程序可运行，需要多个CPU。

程序分类（不是标准的！）：

  • 纯并发：任务仍然在单个CPU上运行。纯并发系统产生的结果比顺序系统更快，但如果有更多的处理器，则运行速度不会更快
  • 并发-并行：使用并发技术，结果程序利用更多处理器并更快地生成结果
  • 并行-并发：使用并行编程技术编写，如果只有一个处理器，结果程序仍然可以运行（Java 8 Streams就是一个很好的例子）。
  • 纯并行：除非有多个处理器，否则不会运行。

进程和线程与并行和并发状态差不多

**进程：**进程间切换开销比较大，一个进程包含一个或多个线程，进程是资源分配的最小单位。

**线程：**每个线程具有独立的数据运行栈和PC（程序计数器），线程切换开销小，线程是CPU可调动的最小单位。

java中六种不同的线程状态

  • **新建（NEW）：**新创建了一个线程，但还没有调用线程的start方法
  • 运行（RUNNABLE），又包括：
  • **就绪（READY）：**运行线程的start方法后，线程位于可运行线程池内，等待被调用；
  • **运行中（RUNNING）：**就绪的线程获得CPU的时间片就变成运行中；
  • **阻塞（BLOCKED）：**线程等待获得锁；
  • **等待（WAITING）：**接受事件通知后或系统中断后进入等待；
  • **超时（TERMINATED）：**线程已执行完毕；

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ul1g5G3t-1639810663389)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20211213151439876.png)]

开启一个线程的四种方式：

  1. 继承Thread类
package T10Thread.FourMethodToImplementThread;

/**
 * @Author: Administrator
 * Date: 2021/12/14 16:34
 * @Version:
 * @Description:
 */
public class First extends Thread{
    @Override
    public void run() {
        System.out.println("继承Thread类创建线程！");
    }

    public static void main(String[] args) {
        First first = new First();
        first.start();
    }
}
  1. 实现Runable接口
package T10Thread.FourMethodToImplementThread;

/**
 * @Author: Administrator
 * Date: 2021/12/14 16:36
 * @Version:
 * @Description:
 */
public class Second implements Runnable {
    @Override
    public void run() {
        System.out.println("实现Runnable接口创建线程！");
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new Second());
        thread.start();
    }
}
  1. 实现Callable接口
package T10Thread.FourMethodToImplementThread;

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

/**
 * @Author: Administrator
 * Date: 2021/12/14 16:40
 * @Version:
 * @Description:实现Callable接口
 */
public class Third implements Callable {
    @Override
    public Object call() throws Exception {
        System.out.println("实现Callable接口创建线程");
        return "result";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask futureTask = new FutureTask(new Third());
        Thread thread = new Thread(futureTask);
        thread.start();
        System.out.println(futureTask.get());
    }
}
  1. 线程池
package T10Thread.FourMethodToImplementThread;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @Author: Administrator
 * Date: 2021/12/14 16:45
 * @Version:
 * @Description:通过线程池创建线程
 */
public class Fourth {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("通过线程池创建");
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    executorService.shutdown();
                }
            }
        });
    }
}

线程间协作

等待和通知：wait()，notify()

等待和通知的标准范式：

等待方：

  1. 获取对象的锁；
  2. 循环里判断条件是否满足，不满足调用wait方法；
  3. 条件满足执行逻辑；

通知方：

  1. 获取对象的锁；
  2. 改变条件；
  3. 通知所有等待在对象上的线程；

join()方法

join()方法把指定的线程加入当前线程，可以将两个交替执行的线程合并为顺序执行的线程；

yield()方法

yield()的作用是让步，它能让当前线程由运行状态进入到就绪状态，从而让其它具有相同优先级的等待线程获取执行权。但是，并不能保证在当前线程调用yield()之后，其它具有相同优先级的线程就一定能获得执行权，也有可能是当前线程又进入到“运行状态”继续运行。

调用yield() 、sleep()、wait()、notify()等方法对锁有何影响？

  • 线程在执行yield()，sleep() 以后，持有的锁是不释放的
  • wait()调动方法之前，必须要持有锁。调用了wait()方法以后，锁就会被释放，当wait方法返回的时候，线程会重新持有锁
  • notify()调动方法之前，必须要持有锁。调用notify()方法本身不会释放锁的，必须执行完notify()方法所在的synchronized代码块后才释放。
  • 当线程呈wait()或sleep()或join()阻塞状态时，调用线程对象的interrupt方法会出现InterruptedException异常。