27.多线程

最新推荐文章于 2024-06-02 22:18:46 发布

海里寻因

最新推荐文章于 2024-06-02 22:18:46 发布

阅读量74

点赞数

分类专栏： JavaSE 文章标签： jvm java 开发语言

本文链接：https://blog.csdn.net/weixin_56006573/article/details/128901046

版权

JavaSE 专栏收录该内容

28 篇文章 1 订阅

订阅专栏

并发：指两个或多个事件在同一个时间段内发生

并行：指两个或多个事件在同一时刻发生（同时发生）

进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程

线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程，一个进程中是可以有多个线程的，这个应用程序可以称之为多线程程序；简而言之，一个程序运行后至少有一个进程，一个进程可以包含多个线程

单核心单线程cpu：cpu在多个线程之间做高速的切换轮流执行多个线程，效率低

4核心8线程：有8个线程可以同时执行，8个线程在多个任务之间做高速的切换，速度是单线程cpu的8倍

线程调度：

分时调度：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间
抢占式调度：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个（线程随机性），Java使用的为抢占式调度

JVM执行main方法，main方法会进入到栈内存；JVM会找操作系统开辟一条main方法通向cpu的执行路径，cpu就可以通过这个路径来执行main方法；而这个路径有一个名字，叫main(主)线程

创建多线程：

第一种方式：创建Thread类的子类（继承Thread)
1. 创建一个Thread类的子类
2. 在子类中重写Thread类中的run方法，设置线程任务
3. 创建子类对象，调用Thread类中的方法start方法，开启新的线程，执行run方法
  1. 多次启动一个线程是非法的，特别是当线程已经结束执行后，不能再重新启动
4. 匿名内部类创建线程：
```
new Thread(){
    @Override
    public void run(){
        .........
    }.start();
}
```
Thread类
1. 构造方法：
  1. public Thread()：分配一个新的线程对象
  2. public Thread(String name)：分配一个指定名字的新的线程对象
  3. public Thread(Runnable target)：分配一个带有指定目标新的线程对象
  4. public Thread(Runnable target,String name)：分配一个带有指定目标新的线程对象并指定名字
2. 常用方法：
  1. public String getName()：获取当前线程名称
  2. public void start()：导致此线程开始执行，java虚拟机调用此线程的run方法
  3. public void run()：此线程要执行的任务在此处定义代码
  4. public static void sleep(long millis)：使当前正在执行的线程以指定的毫秒数暂停
第二种方式：实现Runnable接口
1. 创建一个Runnable接口的实现类
2. 在实现类中重写Runnable接口的run方法，设置线程任务
3. 创建一个Runnable接口的实现类对象
4. 创建Thread类对象，构造方法中传递Runnable接口的实现类对象
5. 调用Thread类中的start方法，开启新的线程执行run方法
6. ```
RunnableImpl run = new RunnableImpl();
Thread t = new Thread(run);
t.start();
```
7. 匿名内部类创建线程：
```
Runnable r = new Runnable(){
    @Override
    public void run(){
        .........
    }.start();
}
new Thread(r).start()
```
8. 好处：
  1. 避免了单继承的局限性
    1. 一个类只能继承一个类，类继承了Thread类就不能继承其他的类
    2. 实现了Runnable接口，还可以继承其他的类，实现其他的接口
    3. 增强了程序的扩展性，降低了程序的耦合性
      1. 实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离（解耦）
      2. 实现类中，重写了run方法：用来设置线程任务
      3. 创建Thread类对象，调用start：用来开启新线程

多线程访问共享的数据会产生线程安全问题

线程同步：

使用同步代码块：

synchronized(锁对象){
    可能会出现线程安全问题的代码
}

执行逻辑：3个线程一起抢夺cpu的执行权，谁抢到了谁执行run方法；t0抢到了cpu的执行权，执行run方法，遇到synchronized代码块，这时t0会检查synchronized代码块是否有锁对象，发现有，就会获取到锁对象，进入到同步中执行；t1抢到了cpu的执行权，执行run方法，遇到synchronized代码块，这时t1会检查synchronized代码块是否有锁对象，发现没有，t1就会进入到阻塞状态会一直等待t0线程归还锁对象；等到t0线程执行完同步中的代码，会把锁对象归还给同步代码块，t1才能获取到锁对象进入到同步中执行
    
    
同步保证了只能有一个线程在同步中执行共享数据，保证了安全；但程序频繁的判断锁，获取锁，释放锁，程序的效率会降低


1.通过代码块中的锁对象，可以让一个线程在同步代码块中执行
2.但是必须保证多个线程使用的锁对象是同一个
3.锁对象作用：把同步代码块锁住，只让一个线程在同步代码块中执行

使用同步方法：

修饰符 synchronized 返回值类型 方法名(参数列表){
    可能会出现线程安全问题的代码
}

执行逻辑：同步方法也会把方法内部的代码锁住，只让一个线程执行，同步方法的锁对象就是实现类对象new RunnableImpl()；也就是this


3. 使用Lock锁

```java
//1.创建一个ReentrantLock对象
Lock l = new ReentrantLock();

l.lock();
........代码
l.unlock();

线程状态：

NEW：新建状态
RUNNABLE：运行状态
BLOCKED：阻塞状态
TERMINATED：死亡状态
WAITING：无限等待状态
TIMED_WAITING：休眠状态
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X2MggtJX-1675664424646)(D:\Typora笔记\Java笔记\JavaSE\thread.jpg)]

/**
*等待唤醒案例：线程通信
*/


void wait()：在其他线程调用此对象的notify方法或notifyAll()方法前，导致当前线程等待
void notify()：唤醒在此对象监视器上等待的单个线程，会继续执行wait方法之后的代码

//创建锁对象，保证唯一
Object obj = new Object();
new Thread(){
    @Override
    public void run(){
        //保证等待和唤醒的线程只能有一个执行，需要使用同步技术
        synchronized (obj){
            //调用wait方法，放弃cpu的执行，进入到WAITING状态
            try{
                obj.wait();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}.start();

new Thread(){
    @Override
    public void run(){
         try{
             Thread.sleep(5000);
         }catch (InterruptedException e){
             e.printStackTrace();
         }
        //保证等待和唤醒的线程只能有一个执行，需要使用同步技术
        synchronized (obj){
            //调用wait方法，放弃cpu的执行，进入到WAITING状态
            try{
                obj.notify();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}.start();

注意事项：通知一个等待的线程，被通知的线程也不能立即恢复执行，因为它当初中断的地方是在同步块内，而此刻它已经不持有锁，所以需要再次尝试去获取锁，成功后才能在当初调用wait方法之后的地方恢复执行



进入到TimeWating(计时等待)有两种方式：
 1.使用sleep(long m)方法，在毫秒值结束之后，线程睡醒进入到Runnable/Blocked状态
 2.使用wait(long m)方法，wait方法如果在毫秒值结束之后，还没有被notify唤醒，就会自动醒来，线程睡醒进入到Runnable/Blocked状态
    
唤醒的方法：
    void notify() 唤醒在此对象监视器上等待的单个线程；如果有多个等待线程，随机唤醒一个
    void notifyAll() 唤醒在此对象监视器上等待的所有线程

线程间通信：

多个线程并发执行时，在默认情况下cpu是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行，那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据

如何保证线程间通信有效利用资源：

多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。就是多个线程在操作同一份数据时，避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段即--------等待唤醒机制

线程池：

就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多的资源

线程池的好处：

降低资源消耗。减少创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行
提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线程的数量，防止因为消耗过多的内存，而把服务器累趴（每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机）

java.util.concurrent.Executors：线程池的工厂类，用来生成线程池
Executors类中的静态方法：
  static ExecutorService newFixedThreadPool(int nThreads) 创建一个可重用固定线程数的线程池
  参数：int nThreads：创建线程池中包含的线程数量
  返回值：
    ExecutorService接口，返回的是ExecutorService接口的实现类对象，可以使用ExecutorService接口接收（面向接口编程）
java.util.concurrent.ExecutorService：线程池接口
    用来从线程池中获取线程，调用start方法，执行线程任务
    	submit(Runnable task)提交一个Runnable任务用于执行
    关闭/销毁线程池的方法
    	void shutdown()
    
 线程池会一直开启，使用完了线程，会自动把线程归还给线程池，线程可以继续使用
    
线程池的使用步骤：
  1.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
    ExecutorService es = Executors.newFixedThreadPool(2)
  2.创建一个类，实现Runnable接口，重写run方法，设置线程任务
  3.调用ExecutorService中的方法submit,传递线程任务（实现类），开启线程，执行run方法
    es.submit(new RunnableImpl());
  4.调用ExecutorService中的方法shutdown销毁线程池（不建议执行）

l生产一个指定线程数量的线程池
ExecutorService es = Executors.newFixedThreadPool(2)
2.创建一个类，实现Runnable接口，重写run方法，设置线程任务
3.调用ExecutorService中的方法submit,传递线程任务（实现类），开启线程，执行run方法
es.submit(new RunnableImpl());
4.调用ExecutorService中的方法shutdown销毁线程池（不建议执行）