【＜多线程常用方法＞】

╰+攻爆jí腚メ 2023-03-06 03:58 4阅读 0赞

### 多线程常用方法 ###

*   *   *   *   *  \[1\] start 与 run
                 *  \[2\] sleep 与 yield
                 *  \[3\] sleep 和 wait
                 *  \[4\] Daemon
                 *  \[5\] join和yield
                 *  \[6\] wait() notify() notifyAll()
                 *  \[7\] await() signal() signalAll()
                 *  \[8\] InterruptedException
                 *  \[9\] interrupted()
                 *  \[10\] Executor
                 *  \[11\] CopyOnWriteArrayList

##### \[1\] start 与 run #####

> https://www.cnblogs.com/agilestyle/p/11421515.html

**start**：用start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行run()方法，这里方法run()称为线程体，它包含了要执行的这个线程的内容，run方法运行结束，此线程随即终止。

**run** ：run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到写线程的目的。

##### \[2\] sleep 与 yield #####

**sleep()**

1.  调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）
2.  其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException
3.  睡眠结束后的线程未必会立刻得到执行
4.  建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性

**yield()**：

对静态方法 Thread.yield() 的调用声明了当前线程已经完成了生命周期中最重要的部分，可以切换给其它线程来执行。该方法只是对线程调度器的一个建议，而且也只是**建议具有相同优先级的其它线程可以运行**。

1.  调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，然后调度执行其它线程
2.  具体的实现依赖于操作系统的任务调度器

> 线程优先级会提示（hint）调度器优先调度该线程，但它仅仅是一个提示，调度器可以忽略它如果 cpu 比较忙，那么优先级高的线程会获得更多的时间片，但 cpu 闲时，优先级几乎没作用

##### \[3\] sleep 和 wait #####

*  \*\*sleep方法：\*\*是Thread类的静态方法，当前线程将睡眠n毫秒，线程进入阻塞状态。当睡眠时间到了，会解除阻塞，进入可运行状态，等待CPU的到来。睡眠不释放锁（如果有的话）。
 *  **wait方法：是Object的方法，必须与synchronized关键字一起使用，线程进入阻塞状态，当notify或者notifyall被调用后，会解除阻塞。但是，只有重新占用互斥锁**之后才会进入可运行状态。睡眠时，会释放互斥锁。

##### \[4\] Daemon #####

默认情况下，Java 进程需要等待所有线程都运行结束，才会结束。有一种特殊的线程叫做守护线程，只要其它非守护线程运行结束了，即使守护线程的代码没有执行完，也会强制结束。

package cn.mycast;
    
    import lombok.extern.slf4j.Slf4j;
    
    import static cn.itcast.n2.util.Sleeper.sleep;
    
    
    @Slf4j(topic= "c.守护线程")
    public class 守护线程 { 
        public static void main(String[] args) { 
            //方法1
            Thread t1 = new Thread(()-> { 
                    sleep(2);
                    log.debug("hello");
            });
            t1.setDaemon(true);
            t1.start();
            sleep(1);
            log.debug("运行结束...");
        }
    }

##### \[5\] join和yield #####

\*\*join 方法：\*\*当前线程调用，则其它线程全部停止，等待当前线程执行完毕，接着执行（**即调用此方法的线程必须加入**）。

**yield 方法：该方法使得线程放弃当前分得的 CPU 时间。但是不使线程阻塞，即线程仍处于可执行状态，随时可能再次分得 CPU 时间。yield()做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。  
但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。  
所以，该方法只是对线程调度器的一个建议，而且也只是建议具有相同优先级的其它线程可以运行**。

##### \[6\] wait() notify() notifyAll() #####

调用 wait() 使得线程等待某个条件满足，线程在等待时会被挂起，当其他线程的运行使得这个条件满足时，其它线程会调用 notify() 或者 notifyAll() 来唤醒挂起的线程。

> 注意：
> 
> 1.  它们都属于 Object 的一部分，而不属于 Thread。
> 2.  只能用在同步方法或者同步控制块中使用，否则会在运行时抛出 IllegalMonitorStateException。
> 3.  使用 wait() 挂起期间，线程会释放锁。这是因为，**如果没有释放锁，那么其它线程就无法进入对象的同步方法或者同步控制块中，那么就无法执行 notify() 或者 notifyAll() 来唤醒挂起的线程，造成死锁**。

##### \[7\] await() signal() signalAll() #####

**await() signal() signalAll()–多线程的协调**。java.util.concurrent 类库中提供了 Condition 类来实现线程之间的协调，可以在 Condition 上调用 await() 方法使线程等待，其它线程调用 signal() 或 signalAll() 方法唤醒等待的线程。

相比于 wait() 这种等待方式，**await() 可以指定等待的条件**，因此更加灵活。

使用 Lock 来获取一个 Condition 对象。

##### \[8\] InterruptedException #####

**InterruptedException–中断机制**，通过调用一个线程的 interrupt() 来中断该线程，如果该线程处于**阻塞、限期等待或者无限期等待状态**，那么就会抛出 InterruptedException，从而提前结束该线程。但是不能中断 I/O 阻塞和 synchronized 锁阻塞。

对于以下代码，在 main() 中启动一个线程之后再中断它，由于线程中调用了 Thread.sleep() 方法，因此会抛出一个 InterruptedException，从而提前结束线程，不执行之后的语句。

try { 
                    Thread.sleep(2000);
                    System.out.println("Thread run");
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }

##### \[9\] interrupted() #####

**interrupted()–中断机制**，如果一个线程的 run() 方法执行一个无限循环，并且没有执行 sleep() 等会抛出 InterruptedException 的操作，那么调用线程的 interrupt() 方法就无法使线程提前结束。

但是调用 interrupt() 方法会设置线程的中断标记，此时调用 interrupted() 方法会返回 true。因此可以**在循环体中**使用 interrupted() 方法来判断线程是否处于中断状态，从而提前结束线程。

##### \[10\] Executor #####

Executor 管理多个异步任务的执行，而无需程序员显式地管理线程的生命周期。这里的异步是指多个任务的执行互不干扰，不需要进行同步操作。主要有三种 Executor：

*  CachedThreadPool：一个任务创建一个线程；
 *  FixedThreadPool：所有任务只能使用固定大小的线程；
 *  SingleThreadExecutor：相当于大小为 1 的 FixedThreadPool。

##### \[11\] CopyOnWriteArrayList #####

CopyOnWriteArraySet 是它的马甲 底层实现采用了 **写入时拷贝** 的思想，增删改操作会将底层数组拷贝一份，修改完毕后，再原子性时候修改共享访问的变量，让它指向新的对象。更改操作在新数组上执行，这时不影响其它线程的并发读，读写分离。