自己学习整理多线程

最新推荐文章于 2023-05-16 16:23:40 发布

so_defficult

最新推荐文章于 2023-05-16 16:23:40 发布

阅读量75

点赞数

分类专栏： Java自学

本文链接：https://blog.csdn.net/so_defficult/article/details/114898787

版权

Java自学专栏收录该内容

8 篇文章 0 订阅

订阅专栏

多线程与并发

程序，进程与线程
程序：一段代码，一组指令的有序集合，它没有运行时没有任何含义，是静态的实体。参考手机的App；
进程：当程序启动运行时，会对代码进行加载、编译，执行一个完整的流程。是一个动态的实体，具有生命周期。就是运行的程序；
线程：进程运行的一个单元（分支），是程序运行的任务。一个程序至少有一个进程；

多线程

多线程：指的是一个程序运行了不止一个线程；
使用多线程的好处：
1.更好的利用CPU资源，提高了效率
2.进程之间不能共享数据，线程可以
3.Java语言内置提供了很多多线程功能，简化Java多线程编程
4.系统在创建进程时，需要为进程分配内存资源等，创建线程的代价比创建进程小

线程的生命周期
线程的生命周期分为：创建（new）、就绪（ready）、运行（running）、阻塞（waiting）、停止（terminated）

在这里插入图片描述

1.创建：一个新创建的线程对象，还没有调用start()方法
2.就绪：当线程调用start()方法后，等待被CPU所执行
3.运行：当获取到CPU资源时，并调用内部的run()方法，线程在运行状态可以转变成阻塞状态或者停止状态
4.阻塞：当一个线程执行了sleep(), wait(), yield()方法等，会将线程挂起，转为阻塞状态。
5.停止：run()方法执行结束或者触发了其他的终止条件

并行与并发

并行：指的是一台电脑拥有多个cpu或者多台电脑同时处理一个任务；
并发：通过cpu的调度算法（时间片轮循或优先级排序），开启多个线程，让用户感觉上是并行的处理任务；
在这里插入图片描述

线程的创建

线程的创建有四种：
(1)继承Thread类，重写run()方法；
(2)实现Runnable接口，实现run()方法；
(3)实现Callable接口，实现call()方法
(4)通过线程池创建线程

继承Thread类创建线程

线程的启动是调用Thread类的start()方法将线程的状态置为就绪。Cpu会根据调度算法运行线程，进行逻辑处理；如果直接调用run()方法，会在main方法直接按照代码执行顺序，依次执行，属于单线程。
在这里插入图片描述

实现Runnable接口创建线程

因为不是继承Thread类，所以不能使用父类的默认属性name，所以调用Thread.currentThread().getName()来返回该线程的名字。

在这里插入图片描述

使用Runnable接口实现的好处：
解决了Java只能单继承的约束问题。
可以实现资源共享。
增加了代码的健壮性，代码可以被多个线程共享，代码和数据独立。
线程池只能放入Runnable或者Callable类的线程，不能放入继承Thread类的线程

Main方法也是一个线程，在java中所有的线程都是同时启动的，至于什么时候，哪个线程先执行，完全看谁先获得CPU。
在Java每次启动的时候默认会开启至少两个线程，main线程和垃圾回收线程（守护线程）。

实现Callable接口创建线程

class MyCallable implements Callable {
	private String name;

	public MyCallable(String name) {
		this.name = name;
	}

	@Override
	public String call() throws Exception {
		return "call:" + name;
	}

	public static void main(String[] args) throws ExecutionException, InterruptedException {
		MyCallable m = new MyCallable("lzl");
		FutureTask futureTask = new FutureTask<>(m);
		Thread t = new Thread(futureTask);
		t.start();
		System.out.println("提前结束");
		Object o = futureTask.get();
		System.out.println("执行完毕"+o);
	}
}

结果为：

在这里插入图片描述

使用Callable接口的优势在：可以有返回值，也可以抛出异常。

线程的调度

Java线程调度的方式有两种：抢占式调度，协作式调度；

抢占式调度：每个线程都有自己的优先级，但是优先级高的并不意味着一定先调度，
而是由CPU随机选择。抢占模式就是一个线程在执行任务时，虽然任务没有执行完毕，但是CPU会迫使它停止，使其他线程占有CPU的使用权。

协作式调度：一个线程在执行自己的任务时，不允许中断，一定要等到当前线程将任务执行完毕后才会释放CPU，其他线程才可以抢占CPU。

抢占式调度不易发生饥饿现象，不易发生因为一个线程影响整个进程的执行，但是其频繁阻塞和调度，会造成系统资源的浪费。协作式调度很容易因为一个线程的问题导致整个线程饥饿

线程调度的优先级：
Java线程的优先级用整数表示，取值范围是1~10，Thread类有三个静态常量：
在这里插入图片描述

优先级越高，获取CPU的使用权几率越大。可以通过Thread类的setPriority()和getPriority()方法对优先级进行调整和获取。

改变线程状态

1.sleep()方法：线程休眠，使正在运行的Java线程进入休眠状态，但不会释放锁。进程处于阻塞状态，当sleep()方法执行完毕之后，线程转为可执行状态。
在这里插入图片描述

最终会调用native的sleep方法（底层方法）
在这里插入图片描述

2.yield()方法：调用yield()方法，会让出CPU的使用权，让CPU执行其它线程，yield()方法也不会释放锁，但yield()方法不能控制具体交出CPU的时间，yield()方法不会进入阻塞状态，会直接转为就绪状态。重新等待获取CPU执行权限。
3.join()方法：在一个线程调用join()方法，会让调用join()方法的线程先执行，当前线程进入阻塞状态，当调用的线程执行完毕后，当前线程继续执行。
4.stop()方法：使线程强制退出。不安全，已弃用。
5.interrupt()方法：调用Thread类的interrupted()方法，其本质只是设置该线程的中断标志，将中断标志设置为true，并根据线程状态决定是否抛出异常。因此，通过interrupted()方法真正实现线程的中断原理是：开发人员根据中断标志的具体值来决定如何退出线程。
6.wait()方法：这个方法是Object的方法，必须与notify()和synchronized(Obj)一起调用，已达到线程同步的效果。Wait()方法是用来暂停线程，类似于sleep()方法，都会进入阻塞状态，待notify()方法唤醒。

线程同步

java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），
将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，
从而保证了该变量的唯一性和准确性。
1.Synchronized关键字：由于synchronized关键字修饰的方法，由于Java每个对象都有一个内置锁，当用此关键字修饰时，内置锁会保护整个方法，调用该方法前，需要先获取内置锁，否则处于阻塞状态。
2.Volatile 关键字：volatile是一个轻量级的synchronized
3.使用重入锁实现线程同步
4.使用局部变量实现线程同步
5.Lock锁
…
线程池
线程池的设计模式：享元模式

线程池顾名思义是一个存放线程的池子，我们创建线程时，有很多种方法，但是都需要去new一个对象，在需要大量线程创建的情况下，这样会很浪费时间和资源。所以可以创建一片内存空间，提前创建一些线程，当有请求时可以从线程池中直接使用线程。

线程池的优点：
第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
第三：提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，
还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。但是，要做到合理利用。

线程池的实现类是ThreadPoolExecutor类。
在这里插入图片描述

ThreadPoolExecutor的构造方法：

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), defaultHandler);
}

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         threadFactory, defaultHandler);
}

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          RejectedExecutionHandler handler) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), handler);
}

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

参数说明：

corePoolSize	核心线程数，默认情况下核心线程一直存活。
maximumPoolSize	线程池中所能容纳的最大线程数
keepAliveTime	线程空闲时间，超过就收回
Unit	时间单元（时，分，秒）
workQueue	任务队列，当需要获取线程时，如果超过了核心线程数，会把任务放在任务队列里
threadFactory	线程工厂
Handler	拒绝策略

拒绝策略：

AbortPolicy（默认）	丢弃任务并抛出RejectedExecutionException异常。
CallerRunsPolicy	由调用线程处理该任务。
DiscardPolicy	丢弃任务，但是不抛出异常。可以配合这种模式进行自定义的处理方式。
DiscardOldestPolicy	丢弃队列最早的未处理任务，然后重新尝试执行任务。

四种常见线程池：

FixedThreadPool ：定长线程池（只有核心线程，线程数固定，执行完立即收回，任务队列为链表结构的有界队列。）

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

CachedThreadPool：可缓存线程池（没有核心线程，非核心线程无限，执行完闲置60s，任务队列为不存储元素的阻塞队列。）

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>(),
                                  threadFactory);
}

ScheduledThreadPool：定时线程池（核心任务数固定，非核心线程数量无限，执行完闲置10ms后回收，任务是延时阻塞队列）

private static final long DEFAULT_KEEPALIVE_MILLIS = 10L;
 
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}
public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE,
          DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
          new DelayedWorkQueue());
}
 
public static ScheduledExecutorService newScheduledThreadPool(
        int corePoolSize, ThreadFactory threadFactory) {
    return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
}
public ScheduledThreadPoolExecutor(int corePoolSize,
                                   ThreadFactory threadFactory) {
    super(corePoolSize, Integer.MAX_VALUE,
          DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
          new DelayedWorkQueue(), threadFactory);
}

SingleThreadExecutor：单线程化线程池（只有一个核心线程，没有非核心线程，执行完立即收回，任务为链表结构的有界队列）

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}
public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>(),
                                threadFactory));
}

执行流程
在这里插入图片描述

so_defficult

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
自己学习整理多线程

多线程与并发程序，进程与线程程序：一段代码，一组指令的有序集合，它没有运行时没有任何含义，是静态的实体。参考手机的App；进程：当程序启动运行时，会对代码进行加载、编译，执行一个完整的流程。是一个动态的实体，具有生命周期。就是运行的程序；线程：进程运行的一个单元（分支），是程序运行的任务。一个程序至少有一个进程；多线程多线程：指的是一个程序运行了不止一个线程；使用多线程的好处：1.更好的利用CPU资源，提高了效率2.进程之间不能共享数据，线程可以3.Java语言内置提供了很多多线程功能，
复制链接

扫一扫