多线程编程

最新推荐文章于 2023-07-19 00:34:37 发布

忧伤夏天的风

最新推荐文章于 2023-07-19 00:34:37 发布

阅读量420

点赞数

分类专栏：笔记文章标签：多线程 java 并发编程

本文链接：https://blog.csdn.net/u014553029/article/details/113879685

版权

笔记专栏收录该内容

17 篇文章 0 订阅

订阅专栏

多线程编程

一、线程

线程（Thread）是并发编程的基础，也是程序执行的最小单元，它依托进程而存在。一个进程中可以包含多个线程，多线程可以共享一块内存空间和一组系统资源，因此线程之间的切换更加节省资源、更加轻量化，也因此被称为轻量级的进程。

1.1 线程创建方式

集成Thread类

 public class OyThread extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " OyThread run 。。。。。。");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        System.out.println("OyThread");
        Thread oyThread = new OyThread();
        oyThread.setName("我的线程0");
        System.out.println("oyThread.getId() = " + oyThread.getId());
        //oyThread.run();
        oyThread.start();
    }
}

实现Runnable接口

public class OyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() +" OyRunnable run 。。。。。。");
    }

    public static void main(String[] args) {
        System.out.println("OyRunnable");
        OyRunnable oyRunnable = new OyRunnable();
        Thread thread = new Thread(oyRunnable,"我的runnable 线程");
        //thread.run();
        thread.start();
    }
}

实现Callable接口(可以通过Future接收执行结果)

public class OyCallable implements Callable {
    @Override
    public Object call() throws Exception {
       	System.out.println(Thread.currentThread().getName() + " OyCallable run 。。。。。。" );
        return "OyCallable call 结果";
    }


    public static void main(String[] args) {
        System.out.println("OyCallable");
        OyCallable oyCallable = new OyCallable();
        FutureTask futureTask = new FutureTask<>(oyCallable);
        futureTask.run();
        try {
            System.out.println("futureTask.get() = " + futureTask.get());
            System.out.println("futureTask.isDone() = " + futureTask.isDone());
            System.out.println("futureTask.isCancelled() = " + futureTask.isCancelled());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

总结：
线程创建方式可以归为两类：继承类和实现接口两种方式。相比继承，接口实现可以更加灵活，不会受限于Java的单继承机制。并且通过实现接口的方式可以共享资源，适合多线程处理同一资源的情况。

1.2 线程状态

线程的状态在 JDK 1.5 之后以枚举的方式被定义在 Thread 的源码中，它总共包含以下 6 个状态：
1. NEW，新建状态，线程被创建出来，但尚未启动时的线程状态；
2. RUNNABLE，就绪状态，表示可以运行的线程状态，它可能正在运行，或者是在排队等待操作系统给它分配 CPU 资源；
3. BLOCKED，阻塞等待锁的线程状态，表示处于阻塞状态的线程正在等待监视器锁，比如等待执行 synchronized 代码块或者使用 synchronized 标记的方法；
4. WAITING，等待状态，一个处于等待状态的线程正在等待另一个线程执行某个特定的动作，比如，一个线程调用了 Object.wait() 方法，那它就在等待另一个线程调用 Object.notify() 或 Object.notifyAll() 方法；
5. TIMED_WAITING，计时等待状态，和等待状态（WAITING）类似，它只是多了超时时间，比如调用了有超时时间设置的方法 Object.wait(long timeout) 和 Thread.join(long timeout) 等这些方法时，它才会进入此状态；
6. TERMINATED，终止状态，表示线程已经执行完成。
线程状态的源代码如下：

public enum State {
    /**
   * 新建状态，线程被创建出来，但尚未启动时的线程状态
   */
    NEW,

    /**
   * 就绪状态，表示可以运行的线程状态，但它在排队等待来自操作系统的 CPU 资源
   */
    RUNNABLE,

    /**
   * 阻塞等待锁的线程状态，表示正在处于阻塞状态的线程
   * 正在等待监视器锁，比如等待执行 synchronized 代码块或者
   * 使用 synchronized 标记的方法
   */
    BLOCKED,

    /**
  * 等待状态，一个处于等待状态的线程正在等待另一个线程执行某个特定的动作。
  * 例如，一个线程调用了 Object.wait() 它在等待另一个线程调用
  * Object.notify() 或 Object.notifyAll()
  */
    WAITING,

    /**
  * 计时等待状态，和等待状态 (WAITING) 类似，只是多了超时时间，比如
  * 调用了有超时时间设置的方法 Object.wait(long timeout) 和 
  * Thread.join(long timeout) 就会进入此状态
  */
    TIMED_WAITING,

    /**
     * 终止状态，表示线程已经执行完成
     */
    }
   TERMINATED;
}

图：线程状态源码
在这里插入图片描述

线程的工作模式是，首先先要创建线程并指定线程需要执行的业务方法，然后再调用线程的 start() 方法，此时线程就从 NEW（新建）状态变成了 RUNNABLE（就绪）状态，此时线程会判断要执行的方法中有没有 synchronized 同步代码块，如果有并且其他线程也在使用此锁，那么线程就会变为 BLOCKED（阻塞等待）状态，当其他线程使用完此锁之后，线程会继续执行剩余的方法。

当遇到 Object.wait() 或 Thread.join() 方法时，线程会变为 WAITING（等待状态）状态，如果是带了超时时间的等待方法，那么线程会进入 TIMED_WAITING（计时等待）状态，当有其他线程执行了 notify() 或 notifyAll() 方法之后，线程被唤醒继续执行剩余的业务方法，直到方法执行完成为止，此时整个线程的流程就执行完了，执行流程如下图所示：
在这里插入图片描述

1.3 线程常用方法

public void start() 　使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
public void run()　如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。
public final void setName(String name)　改变线程名称，使之与参数 name 相同
public final void setPriority(int piority)　更改线程的优先级。
public final void setDaemon(boolean on)　将该线程标记为守护线程或用户线程。
public final void join(long millisec)　等待该线程终止的时间最长为 millis 毫秒。
public void interrupt()　中断线程。
public final boolean isAlive()　测试线程是否处于活动状态。
public static void static yield()　暂停当前正在执行的线程对象，并执行其他线程，当我们把这段代码执行多次之后会发现，每次执行的结果都不相同，这是因为 yield() 执行非常不稳定，线程调度器不一定会采纳 yield() 出让 CPU 使用权的建议，从而导致了这样的结果。。
public static void sleep(long millisec)　在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
public static Thread currentThread()　返回对当前正在执行的线程对象的引用。
join() 在一个线程中调用 other.join() ，这时候当前线程会让出执行权给 other 线程，直到 other 线程执行完或者过了超时时间之后再继续执行当前线程

1.4 常见问题

1.BLOCKED 和 WAITING
虽然 BLOCKED 和 WAITING 都有等待的含义，但二者有着本质的区别，
首先它们状态形成的调用方法不同，其次 BLOCKED 可以理解为当前线程还处于活跃状态，只是在阻塞等待其他线程使用完某个锁资源；
而 WAITING 则是因为自身调用了 Object.wait() 或着是 Thread.join() 又或者是 LockSupport.park() 而进入等待状态，
只能等待其他线程执行某个特定的动作才能被继续唤醒，比如当线程因为调用了 Object.wait() 而进入 WAITING 状态之后，
则需要等待另一个线程执行 Object.notify() 或 Object.notifyAll() 才能被唤醒。

2.start() 和 run()
start() 方法属于 Thread 自身的方法，并且使用了 synchronized 来保证线程安全;
run() 方法为 Runnable 的抽象方法，必须由调用类重写此方法，重写的 run() 方法其实就是此线程要执行的业务方法

3.线程优先级
在 Thread 源码中和线程优先级相关的属性有 3 个：

// 线程可以拥有的最小优先级
public final static int MIN_PRIORITY = 1;
// 线程默认优先级
public final static int NORM_PRIORITY = 5;
// 线程可以拥有的最大优先级
public final static int MAX_PRIORITY = 10

线程的优先级可以理解为线程抢占 CPU 时间片的概率，优先级越高的线程优先执行的概率就越大，但并不能保证优先级高的线程一定先执行。
在程序中我们可以通过 Thread.setPriority() 来设置优先级

二、线程池

线程池是为了避免线程频繁的创建和销毁带来的性能消耗，而建立的一种池化技术，它是把已创建的线程放入“池”中，当有任务来临时就可以重用已有的线程，无需等待创建的过程，这样就可以有效提高程序的响应速度。但如果要说线程池的话一定离不开 ThreadPoolExecutor ，在阿里巴巴的《Java 开发手册》中是这样规定线程池的：

线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的读者更加明确线程池的运行规则，规避资源耗尽的风险。

说明：Executors 返回的线程池对象的弊端如下：

FixedThreadPool 和 SingleThreadPool：允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。

CachedThreadPool 和 ScheduledThreadPool：允许的创建线程数量为 Integer.MAX_VALUE，可能会创建大量的线程，从而导致 OOM。

ThreadPoolExecutor 的核心参数指的是它在构建时需要传递的参数，其构造方法如下所示：

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
    if (corePoolSize < 0 ||
        // maximumPoolSize 必须大于 0，且必须大于 corePoolSize
        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： 表示线程池的常驻核心线程数。如果设置为 0，则表示在没有任何任务时，销毁线程池；如果大于 0，即使没有任务时也会保证线程池的线程数量等于此值。但需要注意，此值如果设置的比较小，则会频繁的创建和销毁线程（创建和销毁的原因会在本课时的下半部分讲到）；如果设置的比较大，则会浪费系统资源，所以开发者需要根据自己的实际业务来调整此值。

maximumPoolSize： 表示线程池在任务最多时，最大可以创建的线程数。官方规定此值必须大于 0，也必须大于等于 corePoolSize 此值只有在任务比较多，且不能存放在任务队列时，才会用到。

keepAliveTime： 表示线程的存活时间，当线程池空闲时并且超过了此时间，多余的线程就会销毁，直到线程池中的线程数量销毁的等于 corePoolSize 为止，如果 maximumPoolSize 等于 corePoolSize，那么线程池在空闲的时候也不会销毁任何线程。

unit： 表示存活时间的单位，它是配合 keepAliveTime 参数共同使用的。

workQueue： 表示线程池执行的任务队列，当线程池的所有线程都在处理任务时，如果来了新任务就会缓存到此任务队列中排队等待执行。

threadFactory： 表示线程的创建工厂，此参数一般用的比较少，我们通常在创建线程池时不指定此参数，它会使用默认的线程创建工厂的方法来创建线程，我们也可以自定义一个线程工厂，通过实现ThreadFactory 接口来完成，这样就可以自定义线程的名称或线程执行的优先级了。

RejectedExecutionHandler： 表示指定线程池的拒绝策略，当线程池的任务已经在缓存队列 workQueue中存储满了之后，并且不能创建新的线程来执行此任务时，就会用到此拒绝策略，它属于一种限流保护的机制。

线程池执行流程：

在这里插入图片描述
知识扩展

1. execute() VS submit()：

execute() 和 submit() 都是用来执行线程池任务的，它们最主要的区别是，submit() 方法可以配合 Futrue 来接收线程执行的返回值，而 execute() 不能接收返回值。
另一个区别是 execute() 方法属于 Executor 接口的方法，而 submit() 方法则是属于ExecutorService 接口的方法
2. 线程池的拒绝策略：
当线程池中的任务队列已经被存满，再有任务添加时会先判断当前线程池中的线程数是否大于等于线程池的最大值，如果是，则会触发线程池的拒绝策略。

Java 自带的拒绝策略有 4 种：
AbortPolicy，终止策略，线程池会抛出异常并终止执行，它是默认的拒绝策略；
CallerRunsPolicy，把任务交给当前线程来执行；
DiscardPolicy，忽略此任务（最新的任务）；
DiscardOldestPolicy，忽略最早的任务（最先加入队列的任务）。

3.自定义拒绝策略
自定义拒绝策略只需要新建一个 RejectedExecutionHandler 对象，然后重写它的 rejectedExecution() 方法。

ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 5, 1,
        TimeUnit.SECONDS, new LinkedBlockingQueue<>(5),
        new RejectedExecutionHandler() {  // 添加自定义拒绝策略
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                // 业务处理方法
                System.out.println("执行自定义拒绝策略");
            }
        });

4.ThreadPoolExecutor 扩展
ThreadPoolExecutor 的扩展主要是通过重写它的 beforeExecute() 和 afterExecute() 方法实现的，我们可以在扩展方法中添加日志或者实现数据统计。

三、AQS

AQS：AQS的全称为（AbstractQueuedSynchronizer，抽象的队列式同步器），这个类在java.util.concurrent.locks包（即使JUC中），是除了java自带的synchronized关键字之外的锁机制。

AQS的核心思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并将共享资源设置为锁定状态，如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制AQS是用CLH队列锁实现的，即将暂时获取不到锁的线程加入到队列中。
CLH（Craig，Landin，and Hagersten) 队列是一个虚拟的双向队列，虚拟的双向队列即不存在队列实例，仅存在节点之间的关联关系。
AQS是将每一条请求共享资源的线程封装成一个CLH锁队列的一个结点（Node），来实现锁的分配。

实现了AQS的锁有：自旋锁、互斥锁、读锁写锁、条件产量、信号量、栅栏都是AQS的衍生物
在这里插入图片描述
它维护了一个volatile int state（代表共享资源）和一个FIFO线程等待队列（多线程争用资源被阻塞时会进入此队列）。这里volatile是核心关键词，具体volatile的语义，在此不述。state的访问方式有三种:

getState()
setState()
compareAndSetState()
　 AQS定义两种资源共享方式：Exclusive（独占，只有一个线程能执行，如ReentrantLock）和Share（共享，多个线程可同时执行，如Semaphore/CountDownLatch）。

不同的自定义同步器争用共享资源的方式也不同。自定义同步器在实现时只需要实现共享资源state的获取与释放方式即可，至于具体线程等待队列的维护（如获取资源失败入队/唤醒出队等），AQS已经在顶层实现好了。自定义同步器实现时主要实现以下几种方法：

isHeldExclusively()：该线程是否正在独占资源。只有用到condition才需要去实现它。
tryAcquire(int)：独占方式。尝试获取资源，成功则返回true，失败则返回false。
tryRelease(int)：独占方式。尝试释放资源，成功则返回true，失败则返回false。
tryAcquireShared(int)：共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
tryReleaseShared(int)：共享方式。尝试释放资源，如果释放后允许唤醒后续等待结点返回true，否则返回false。

以ReentrantLock为例，state初始化为0，表示未锁定状态。A线程lock()时，会调用tryAcquire()独占该锁并将state+1。此后，其他线程再tryAcquire()时就会失败，直到A线程unlock()到state=0（即释放锁）为止，其它线程才有机会获取该锁。当然，释放锁之前，A线程自己是可以重复获取此锁的（state会累加），这就是可重入的概念。但要注意，获取多少次就要释放多么次，这样才能保证state是能回到零态的。

再以CountDownLatch以例，任务分为N个子线程去执行，state也初始化为N（注意N要与线程个数一致）。这N个子线程是并行执行的，每个子线程执行完后countDown()一次，state会CAS减1。等到所有子线程都执行完后(即state=0)，会unpark()主调用线程，然后主调用线程就会从await()函数返回，继续后余动作。

一般来说，自定义同步器要么是独占方法，要么是共享方式，他们也只需实现tryAcquire-tryRelease、tryAcquireShared-tryReleaseShared中的一种即可。但AQS也支持自定义同步器同时实现独占和共享两种方式，如ReentrantReadWriteLock。

忧伤夏天的风

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
多线程编程

多线程编程一、线程线程（Thread）是并发编程的基础，也是程序执行的最小单元，它依托进程而存在。一个进程中可以包含多个线程，多线程可以共享一块内存空间和一组系统资源，因此线程之间的切换更加节省资源、更加轻量化，也因此被称为轻量级的进程。1.1 线程创建方式（1）集成Thread类（2）实现Runnable接口（3）实现Callable接口(可以通过Future接收执行结果)1.2 线程状态线程的状态在 JDK 1.5 之后以枚举的方式被定义在 Thread 的源码中，它总共包含以下
复制链接

扫一扫