Java高并发的基础——多线程相关知识讲解及实验(后续会有补充)

并发与并行：

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

并发一段时间内多个程序可运行，一个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();
    }
}

2. 实现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();
       }
   }
   
   

3. 实现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());
       }
   }
   

4. 线程池

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异常。

感谢您的阅读，如果本篇文章对您有帮助，欢迎点赞，关注，您的阅读是我莫大的鼓励！