本文详细介绍了Java中的多线程概念，包括线程的创建、启动、休眠、中断、优先级、礼让和加入，以及线程锁和线程同步。重点讨论了`synchronized`关键字在保证线程安全中的作用，同时提到了死锁的概念和避免方法。此外，还探讨了`ThreadLocal`的使用以及并行流`parallelStream`在集合类操作中的应用。
多线程
文章目录
进程概念
进程是程序执行的实体，每一个进程都是一个应用程序，比如我们运行的软件，都有自己的内存空间；CPU一个核心同时只能处理一件事情，当出现多个进程需要同时进行时，CPU一般采用时间片轮转调度算法，来实现多个进程同时运行
在早期的计算机中，进程是拥有资源和独立运行的最小单位，也是程序执行的最小单位
但是如果希望两个任务同时进行，就必须运行两个进程，每个进程都有一个自己的内存空间，进程之间的通信就会变得麻烦，而且执行不同进程会产生上下文的切换，非常耗时，那么能否实现在一个进程中就能够执行多个任务?
后来，线程出现，一个进程可以有多个线程；
线程：程序执行中一个单一的顺序控制流程；现在，线程才是程序执行流的最小单位，各个线程之间共享程序的内存空间（也就是所在进程的内存空间），上下文切换速度也高于进程
在Java中，从一开始编写的都是单线程应用程序（运行main()方法的内容），也就是说只能同时执行一个任务；而如果我们希望同时执行多个任务（两个方法同时在运行或者是两个计算同时在进行，也就是异步），就需要使用到 Java多线程框架
实际上一个Java程序启动之后，会创建很多线程，而不仅仅是只运行一个主线程
public static void main(String[] args) {
ThreadMXBean bean = ManagementFactory.getThreadMXBean();
long[] ids = bean.getAllThreadIds();
ThreadInfo[] infos = bean.getThreadInfo(ids);
for(ThreadInfo info : infos) {
System.out.println(info.getThreadName());
}
}
输出
main
Reference Handler
Finalizer
Signal Dispatcher
Attach Listener
Common-Cleaner
Monitor Ctrl-Break
Notification Thread
线程的创建和启动
通过创建Thread对象来创建一个新的线程，Thread构造方法需要传入一个Runnable接口的实现，其实就是编写要在另一个线程执行的内容逻辑
同时Runnable只有一个未实现方法，因此可以直接使用lambda表达式
@FunctionalInterface
public interface Runnable {
/**
* When an object implementing interface <code>Runnable</code> is used
* to create a thread, starting the thread causes the object's
* <code>run</code> method to be called in that separately executing
* thread.
* <p>
* The general contract of the method <code>run</code> is that it may
* take any action whatsoever.
*
* @see java.lang.Thread#run()
*/
public abstract void run();
}
创建好后，通过调用start()方法来运行此线程：
public static void mian(String[] args) {
Thread t = new Thread(() -> {
System.out.println("another");
}) ;
t.start(); //调用此方法来开始执行此线程
}
看下面这个例子
这段代码执行输出结果并不是按照从上往下的顺序了，因为他们分别位于两个线程，他们是同时进行的
public static void main(String[] args) {
Thread t = new Thread(() -> {
System.out.println("我是线程："+Thread.currentThread().getName());
System.out.println("我正在计算 0-10000 之间所有数的和...");
int sum = 0;
for (int i = 0; i <= 10000; i++) {
sum += i;
}
System.out.println("结果："+sum);
});
t.start();
System.out.println("我是主线程！");
}
输出
我是主线程！
我是线程：Thread-0
我正在计算 0-10000 之间所有数的和...
结果：50005000
再来一个
可以观察到是交替进行的
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
for (int i = 0; i < 50; i++) {
System.out.println("我是一号线程："+i);
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 50; i++) {
System.out.println("我是二号线程："+i);
}
});
t1.start();
t2.start();
}
部分输出
...
我是二号线程：3
我是一号线程：4
我是二号线程：4
我是一号线程：5
我是二号线程：5
我是一号线程：6
我是二号线程：6
...
注意：我们发现还有一个run方法，也能执行线程里面定义的内容，但是run是直接在当前线程执行，并不是创建一个线程执行
sleep()
实际上，线程和进程差不多，也会等待获取CPU资源，一旦获取，就可以按照顺序执行给定的程序，当需要等待外部IO操作，就会暂时处于休眠状态，等待通知
或者调用sleep()方法(以毫秒为单位) ，让当前线程休眠一段时间：
public static void main(String[] args) throws InterruptedException {
System.out.println("l");
Thread.sleep(1000); //休眠时间，以毫秒为单位，1000ms = 1s
System.out.println("b");
Thread.sleep(1000);
System.out.println("w");
Thread.sleep(1000);
System.out.println("nb!");
}
stop()
强行终止此线程；但不推荐
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(() -> {
Thread me = Thread.currentThread(); //获取当前线程对象
for (int i = 0; i < 50; i++) {
System.out.println("打印:"+i);
if(i == 20) me.stop(); //此方法会直接终止此线程
}
});
t.start();
}
你猜
我们发现，value最后的值并不是我们理想的结果
private static int value = 0;
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
for (int i = 0; i < 10000; i++) value++;
System.out.println("线程1完成");
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 10000; i++) value++;
System.out.println("线程2完成");
});
t1.start();
t2.start();
Thread.sleep(1000); //主线程停止1秒，保证两个线程执行完成
System.out.println(value);
}
线程的休眠和中断
前面提到，一个线程处于运行状态下，线程的下一个状态会出现以下情况：
- 当CPU给予的运行时间结束时，会从运行状态回到就绪（可运行）状态，等待下一次获得CPU资源。
- 当线程进入休眠 / 阻塞(如等待IO请求) / 手动调用
wait()方法时，会使得线程处于等待状态，当等待状态结束后会回到就绪状态。 - 当线程出现异常或错误 / 被
stop()方法强行停止 / 所有代码执行结束时，会使得线程的运行终止。
如何使线程进入休眠状态
public static void main(String[] args) {
Thread t = new Thread (() -> {
try{
System.out.println("l");
Thread.sleep(1000);
System.out.println("b");
} catch (InterruptedException e) {
e.printStackTrace();
}
});
t.start();
}
异常发生
public static void main(String[] args) {
Thread t = new Thread(() -> {
try {
Thread.sleep(10000); //休眠10秒
} catch (InterruptedException e) {
e.printStackTrace();
}
});
t.start();
try {
Thread.sleep(3000); //休眠3秒，一定比线程t先醒来
t.interrupt(); //调用t的interrupt方法
} catch (InterruptedException e) {
e.printStackTrace();
}
}
输出
每一个Thread对象中，都有一个interrupt()方法，调用此方法后，会给指定线程添加一个中断标记以告知线程需要立即停止运行或是进行其他操作，由线程来响应此中断并进行相应的处理
我们前面提到的stop()方法是强制终止线程，这样的做法虽然简单粗暴，但是很有可能导致资源不能完全释放；
而类似这样的发送通知来告知线程需要中断，让线程自行处理后续，会更加合理一些，也是更加推荐的做法。我们来看看interrupt的用法：
public static void main(String[] args) {
Thread t = new Thread(() -> {
System.out.println("线程开始运行！");
while (true){ //无限循环
if(Thread.currentThread().isInterrupted()){ //判断是否存在中断标志
break; //响应中断
}
}
System.out.println("线程被中断了！");
});
t.start();
try {
Thread.sleep(3000); //休眠3秒，一定比线程t先醒来
t.interrupt(); //调用t的interrupt方法
} catch (InterruptedException e) {
e.printStackTrace();
}
}
通过isInterrupted()方法可以判断线程是否存在中断标志；
如果存在，说明外部希望当前线程立即停止，也有可能是给当前线程发送一个其他的信号，如果我们不希望收到中断信号就结束程序，而是通知程序做其他的；那么我们可以在收到中断信号之后，复位中断标记，然后继续
public static void main(String[] args) {
Thread t = new Thread (() -> {
System.out.println("线程开始运行");
while(true) {
if(Thread.currentThread().isInterrupted()) { //判断是否存在中断标记
System.out.println("发现中断信号，复位，继续");
Thread.interrupted(); //复位
}
}
});
t.start();
try{
Thread.sleep(1000);
t.interrupt();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
复位中断标记后，会立即清除中断标记
我们希望线程暂时停下，比如等待其他线程执行完成后，再继续运行操作
public static void main(String[] args) {
Thread t = new Thread(() -> {
System.out.println("线程开始运行！");
Thread.currentThread().suspend(); //暂停此线程
System.out.println("线程继续运行！");
});
t.start();
try {
Thread.sleep(3000); //休眠3秒，一定比线程t先醒来
t.resume(); //恢复此线程
} catch (InterruptedException e) {
e.printStackTrace();
}
}
虽然这样很方便地控制了线程的暂停状态，但是这两个方法我们发现实际上也是不推荐的做法，它很容易导致死锁！
线程的优先级
实际上，Java程序中的每个线程并不是平均分配CPU时间的，为了使得线程资源分配更加合理，Java采用的是抢占式调度方式，优先级越高的线程，优先使用CPU资源！我们希望CPU花费更多的时间去处理更重要的任务，而不太重要的任务，则可以先让出一部分资源。线程的优先级一般分为以下三种：
- MIN_PRIORITY 最低优先级
- MAX_PRIORITY 最高优先级
- NOM_PRIORITY 常规优先级
优先级越高的线程，获得CPU资源的概率会越大，并不是优先级越高的线程越先执行
public static void main(String[] args) {
Thread t = new Thread(() -> {
System.out.println("线程开始运行！");
});
t.start();
t.setPriority(Thread.MIN_PRIORITY); //通过使用setPriority方法来设定优先级
}
线程的礼让和加入
yield()
我们可以在当前线程工作不重要的时候，将CPU资源让位给其他线程，通过使用yield()来将当前资源让位给其他同优先级线程：
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
System.out.println("线程1开始运行！");
for (int i = 0; i < 50; i++) {
if(i % 5 == 0) {
System.out.println("让位！");
Thread.yield();
}
System.out.println("1打印："+i);
}
System.out.println("线程1结束！");
});
Thread t2 = new Thread(() -> {
System.out.println("线程2开始运行！");
for (int i = 0; i < 50; i++) {
System.out.println("2打印："+i);
}
});
t1.start();
t2.start();
}
观察结果，发现让位之后，尽可能多的执行线程2的内容
stop()
当我们希望一个线程等待另一个线程执行完成后再继续进行，可以使用join方法来实现线程的加入
线程1加入后，线程2等待线程1待执行的内容全部执行完成之后，再继续执行的线程2内容。注意，线程的加入只是等待另一个线程的完成，并不是将另一个线程和当前线程合并
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
System.out.println("线程1开始运行！");
for(int i=0; i<50; i++) {
System.out.println("1打印" + i);
}
System.out.println("线程1结束！");
});
Thread t2 = new Thread(() -> {
System.out.println("线程2开始运行！");
for(int i=0; i<50; i++){
System.out.println("2打印" + i);
if(10 == i) {
try {
System.out.println("线程1加入");
t1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
t1.start();
t2.start();
}
线程锁和线程同步
多线程情况下Java的内存管理
线程之间的共享变量（比如之前悬念中的value变量），存储在主内存（main memory）
每个线程中都有一个私有的工作内存（本地内存），工作内存中存储了该线程以读/写共享变量的副本，类似于在计算机组成原理中学习的多核心处理器高速缓存机制：
高速缓存通过保存内存中数据的副本来提供更加快速的数据访问，但是如果多个处理器的运算任务都涉及同一块内存区域，就可能导致各自的高速缓存数据不一致，在写回主内存的时候就会发生冲突，这就是引入告诉缓存引发的新问题，也就是缓存一致性
例如
private static int value = 0;
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
for (int i = 0; i < 10000; i++) value++;
System.out.println("线程1完成");
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 10000; i++) value++;
System.out.println("线程2完成");
});
t1.start();
t2.start();
Thread.sleep(1000); //主线程停止1秒，保证两个线程执行完成
System.out.println(value);
}
实际上，当线程同时读取value的时候，可能同时拿到同样的值，而进行自增操作的时候，也是同样的值，再写回主内存的时候，本应该进行两次的却只进行了一次
synchronized 关键字
通过synchronized关键字创造一个线程锁，他需要在括号中填入一个内容。必需是一个对象或者一个类，我们在value自增操作外套上同步代码块
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
for(int i=0; i<10000; i++) {
Synchronized (Main.class) {
value++;
}
}
System.out.println("线程1完成");
});
Thread t2 = new Thread(() -> {
for(int i=0; i<10000; i++) {
Synchronized (Main.class) {
value++;
}
}
System.out.println("线程2完成");
});
t1.start();
t2.start();
Thread.sleep(1000);
System.out.println(value);
}
在同步代码块执行的过程中，拿到了我们传入对象或类的锁；传入的是对象，则是对象锁，不同的对象有着不同的对象锁，如果是类，就是类锁，类锁只有一个。实际上类锁也是对象锁；是Class类实例，但是Class类实例同样的类无论怎么获取都是同一个；但是注意两个线程必须使用同一把锁
当一个线程进入到同步代码块时，会获取到当前的锁，而这时如果其他使用同样的锁的同步代码块也想执行内容，就必须等待当前的同步代码块的内容执行完毕；在执行完毕之后会自动释放这把锁，而其他的线程才能拿到这把锁并开始执行同步代码块里面的内容；
实际上synchronized是一种悲观锁，随时都认为有其他线程在对数据进行修改
如果使用的是不同对象的锁，能顺利进行吗？
当对象不同的时候，获取到的是不同的锁，因此不能保证自增操作的原子性，最后也得不到想要的结果
synchronized关键字也可以作用于方法上，调用此方法时也会获取锁：
实际上效果是相同的，只不过这个锁不用你去给，如果是静态方法，就是使用的类锁，而如果是普通成员方法，就是使用的对象锁。通过灵活的使用synchronized就能很好地解决我们之前提到的问题了
private static int value = 0;
private static synchronized void add(){
value++;
}
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
for (int i = 0; i < 10000; i++) add();
System.out.println("线程1完成");
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 10000; i++) add();
System.out.println("线程2完成");
});
t1.start();
t2.start();
Thread.sleep(1000); //主线程停止1秒，保证两个线程执行完成
System.out.println(value);
}
死锁
概念
两个线程相互持有对方需要的锁，但是又迟迟不释放，导致程序卡住
线程A和线程B都需要对方的锁，但是又被对方牢牢把握，由于线程被无限期地阻塞，因此程序不可能正常终止
public static void main(String[] args) throws InterruptedException {
Object o1 = new Object();
Object o2 = new Object();
Thread t1 = new Thread(() -> {
synchronized (o1){
try {
Thread.sleep(1000);
synchronized (o2){
System.out.println("线程1");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
Thread t2 = new Thread(() -> {
synchronized (o2){
try {
Thread.sleep(1000);
synchronized (o1){
System.out.println("线程2");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t1.start();
t2.start();
}
可以使用jps和jstack来找到死锁
jstack自动帮助我们找到了一个死锁，并打印出了相关线程的栈追踪信息，同样的，使用jconsole也可以进行监测
PS C:\Users\lenovo\IdeaProjects\ArrayList> jps
17044
4388 Launcher
9768 Jps
17692 Main
PS C:\Users\lenovo\IdeaProjects\ArrayList> jstack 17692
2023-05-03 20:31:51
Full thread dump OpenJDK 64-Bit Server VM (20.0.1+9-29 mixed mode, sharing):
Threads class SMR info:
...
java.lang.Thread.State: RUNNABLE
"Thread-0" #22 [7988] prio=5 os_prio=0 cpu=0.00ms elapsed=20.85s tid=0x0000022065a51d60 nid=7988 waiting for monitor entry [0x00000058740ff000]
java.lang.Thread.State: BLOCKED (on object monitor)
at Main.lambda$main$0(Main.java:19)
- waiting to lock <0x000000071391e408> (a java.lang.Object)
- locked <0x000000071391e3f8> (a java.lang.Object)
at Main$$Lambda$14/0x00000008010031f8.run(Unknown Source)
at java.lang.Thread.runWith(java.base@20.0.1/Thread.java:1636)
at java.lang.Thread.run(java.base@20.0.1/Thread.java:1623)
"Thread-1" #23 [17512] prio=5 os_prio=0 cpu=0.00ms elapsed=20.85s tid=0x0000022065a52d50 nid=17512 waiting for monitor entry [0x00000058741ff000]
java.lang.Thread.State: BLOCKED (on object monitor)
at Main.lambda$main$1(Main.java:31)
- waiting to lock <0x000000071391e3f8> (a java.lang.Object)
- locked <0x000000071391e408> (a java.lang.Object)
at Main$$Lambda$15/0x0000000801003410.run(Unknown Source)
at java.lang.Thread.runWith(java.base@20.0.1/Thread.java:1636)
at java.lang.Thread.run(java.base@20.0.1/Thread.java:1623)
...
Found 1 deadlock.
因此，前面说不推荐使用 suspend()去挂起线程的原因，是因为suspend()在使线程暂停的同时，并不会去释放任何锁资源。其他线程都无法访问被它占用的锁。直到对应的线程执行resume()方法后，被挂起的线程才能继续，从而其它被阻塞在这个锁的线程才可以继续执行。但是，如果resume()操作出现在suspend()之前执行，那么线程将一直处于挂起状态，同时一直占用锁，这就产生了死锁
wait & notify method
Object类还有三个方法我们从来没有使用过，分别是wait()、notify()以及notifyAll()，他们其实是需要配合synchronized来使用的（实际上锁就是依附于对象存在的，每个对象都应该有针对于锁的一些操作，所以说就这样设计了）当然，只有在同步代码块中才能使用这些方法，正常情况下会报错
public static void main(String[] args) throws InterruptedException {
Object o1 = new Object();
Thread t1 = new Thread(() -> {
synchronized (o1){
try {
System.out.println("开始等待");
o1.wait(); //进入等待状态并释放锁
System.out.println("等待结束！");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
Thread t2 = new Thread(() -> {
synchronized (o1){
System.out.println("开始唤醒！");
o1.notify(); //唤醒处于等待状态的线程
for (int i = 0; i < 50; i++) {
System.out.println(i);
}
//唤醒后依然需要等待这里的锁释放之前等待的线程才能继续
}
});
t1.start();
Thread.sleep(1000);
t2.start();
}
对象的wait()方法会暂时使得此线程进入等待状态，同时会释放当前代码块持有的锁，这时其他线程可以获取到此对象的锁
当其他线程调用对象的notify()方法后，会唤醒刚才变成等待状态的线程（这时并没有立即释放锁）
注意，必须是在持有锁（同步代码块内部）的情况下使用，否则会抛出异常
notifyAll其实和notify一样，也是用于唤醒，但是前者是唤醒所有调用wait()后处于等待的线程，而后者是看运气随机选择一个
ThreadLocal的使用
既然每个线程都有一个自己的工作内存，那么能否只在自己的工作内存中创建变量仅供线程
我们可以使用ThreadLocal类，来创建工作内存中的变量，它将我们的变量值存储在内部（只能存储一个变量），不同的线程访问到ThreadLocal对象时，都只能获取到当前线程所属的变量
public static void main(String[] args) throws InterruptedException {
ThreadLocal<String> local = new ThreadLocal<>(); //注意这是一个泛型类，存储类型为我们要存放的变量类型
Thread t1 = new Thread(() -> {
local.set("lbwnb"); //将变量的值给予ThreadLocal
System.out.println("变量值已设定！");
System.out.println(local.get()); //尝试获取ThreadLocal中存放的变量
});
Thread t2 = new Thread(() -> {
System.out.println(local.get()); //尝试获取ThreadLocal中存放的变量
});
t1.start();
Thread.sleep(3000); //间隔三秒
t2.start();
}
上面的例子中，开启两个线程分别去访问ThreadLocal对象，发现，第一个线程存放的内容。第一个线程可以获取；但是第二个线程无法获取，我们再来看看第一个线程存入后，第二个线程也存放，不会覆盖第一个线程存放的内容：
public static void main(String[] args) {
ThreadLocal<String> local = new ThreadLocal<>();
Thread t1 = new Thread(() -> {
local.set("asdfg");
System.out.println("线程1变量值已设定！ ");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程1读取变量值");
System.out.println(local.get());
});
Thread t2 = new Thread(() -> {
local.set("yyds"); //将变量的值给予ThreadLocal
System.out.println("线程2变量值已设定！");
});
t1.start();
Thread.sleep(1000); //间隔1秒
t2.start();
}
即使线程2重新设定了值，也没有影响到线程1存放的值，所以说，不同线程向ThreadLocal存放数据，只会存放在线程自己的工作空间中，而不会直接存放到主内存中，因此各个线程直接存放的内容互不干扰
发现在线程中创建的子线程，无法获得父线程工作内存中的变量：
public static void main(String[] args) {
ThreadLocal<String> local = new ThreadLocal<>();
Thread t = new Thread(() -> {
local.set("asdfg");
new Thread(() -> {
System.out.println(local.get());
}).start();
});
t.start();
}
可以使用InheritableThreadLocal解决：
在InheritableThreadLocal存放的内容，会自动向子线程传递
public static void main(String[] args) {
ThreadLocal<String> local = new InheritableThreadLocal<>();
Thread t = new Thread(() -> {
local.set("asdfg");
new Thread(() -> {
System.out.println(local.get());
}).start();
});
t.start();
}
定时器 Timer
有时候会有这样的需求，我希望定时执行任务，比如3秒后执行，其实我们可以通过使用Thread.sleep()来实现：
public static void main(String[] args) {
Timer timer = new Timer(); //创建定时器对象
timer.schedule(new TimerTask() { //注意这个是一个抽象类，不是接口，无法使用lambda表达式简化，只能使用匿名内部类
@Override
public void run() {
System.out.println(Thread.currentThread().getName()); //打印当前线程名称
}
}, 1000); //执行一个延时任务
}
可以通过创建Timer类让它来进行定时任务调度，可以通过此对象来创建任意类型的定时任务、包延时任务、循环定时任务等；
虽然任务执行完成了，但是程序并未停止，是因为timer内存维护了一个任务队列和工作线程：
public class Timer {
/**
* The timer task queue. This data structure is shared with the timer
* thread. The timer produces tasks, via its various schedule calls,
* and the timer thread consumes, executing timer tasks as appropriate,
* and removing them from the queue when they're obsolete.
*/
private final TaskQueue queue = new TaskQueue();
/**
* The timer thread.
*/
private final TimerThread thread = new TimerThread(queue);
...
}
TimerThread继承自Thread，是一个新创建的线程，在构造时自动启动：
public Timer(String name) {
thread.setName(name);
thread.start();
}
而它的run方法会循环地读取队列中是否还有任务，如果有任务依次执行，没有的话就暂时处于休眠状态：
public void run() {
try {
mainLoop();
} finally {
// Someone killed this Thread, behave as if Timer cancelled
synchronized(queue) {
newTasksMayBeScheduled = false;
queue.clear(); // Eliminate obsolete references
}
}
}
/**
* The main timer loop. (See class comment.)
*/
private void mainLoop() {
try {
TimerTask task;
boolean taskFired;
synchronized(queue) {
// Wait for queue to become non-empty
while (queue.isEmpty() && newTasksMayBeScheduled) //当队列为空同时没有被关闭时，会调用wait()方法暂时处于等待状态，当有新的任务时，会被唤醒。
queue.wait();
if (queue.isEmpty())
break; //当被唤醒后都没有任务时，就会结束循环，也就是结束工作线程
...
}
newTasksMayBeScheduled实际上就是标记当前定时器是否关闭，当它为false时，表示已经不会再有新的任务到来，也就是关闭，我们可以通过调用cancel()方法来关闭它的工作线
public void cancel() {
synchronized(queue) {
thread.newTaskMaybeScheduled = false;
queue.clear();
queu.notify(); //唤醒wait使得工作线程结束
}
}
在使用完成后，调用Timer的cancel()方法以正常退出我们的程序：
public static void main(String[] args) {
Timer timer = new Timer();
timer.scheduled(new TimerTask() {
@Override
public void run() {
System.out.println(Thread.currentThread(),getName());
timer.cancel();
}
}, 1000);
}
守护线程
守护线程当其他所有的非守护线程结束之后，守护线程自动结束，也就是说，Java中的所有的线程都执行完毕之后，守护线程自动结束，因此，守护线程不适合进行IO操作，只适合打杂
public static void main(String[] args) throws InterruptedException{
Thread t = new Thread(() -> {
while (true){
try {
System.out.println("程序正常运行中...");
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t.setDaemon(true); //设置为守护线程（必须在开始之前，中途是不允许转换的）
t.start();
for (int i = 0; i < 5; i++) {
Thread.sleep(1000);
}
}
在守护线程中产生的新线程也是守护的
public static void main(String[] args) throws InterruptedException{
Thread t =new Thread (() -> {
Thread it = new Thread(() -> {
while(true) {
try {
System.out.println("程序正常运行中");
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
it.start();
});
t.setDaemon(true); //设置为守护线程（必须在开始之前）
t.start();
for(int i=0; i<5; i++) {
Thread.sleep(1000);
}
}
再谈集合类
集合类中有一个东西是Java8新增的Spliterator接口，翻译过来就是：可拆分迭代器（Splitable Iterator）和Iterator一样，Spliterator也用于遍历数据源中的元素，但它是为了并行执行而设计的。Java 8已经为集合框架中包含的所有数据结构提供了一个默认的Spliterator实现。在集合跟接口Collection中提供了一个spliterator()方法用于获取可拆分迭代器
parallelStream
集合类的根接口，有一个这样的方法
default Stream<E> parallelStream() {
return StreamSupport.stream(spliterator(), true); //parallelStream就是利用了可拆分迭代器进行多线程操作
}
并行流，其实就是一个多线程执行的流，通过默认的ForkJoinPool实现，可以提高多线程任务的速度
public static void main(String[] args) {
List<Integer> list = new ArrayList<>(Arrays.asList(1,4,5,2,9,3,6,0));
list
.parallelStream()
.forEach(i -> System.out.println(Thread.currentThread().getName() + "->" + i));
}
forEachOrdered()
我们发现，forEach操作的顺序，并不是我们实际List中的顺序，同时每次打印也是不同的线程在执行！我们可以通过调用forEachOrdered()方法来使用单线程维持原本的顺序：
public static void main(String[] args) {
List<Integer> list = new ArrayList<>(Arrays.asList(1, 4, 5, 2, 9, 3, 6, 0));
list
.parallelStream() //获得并行流
.forEachOrdered(System.out::println);
}
在Arrays数组工具类中，也包含大量的并行方法：
public static void main(String[] args) {
int[] arr = new int[]{1, 4, 5, 2, 9, 3, 6, 0};
Arrays.parallelSort(arr); //使用多线程进行并行排序，效率更高
System.out.println(Arrays.toString(arr));
}
更多地使用并行方法，可以更加充分地发挥现代计算机多核心的优势，但是同时需要注意多线程产生的异步问题
public static void main(String[] args) {
int[] arr = new int[]{1,4,5,2,9,3,6,0};
Arrays.parallelSetAll(arr, i -> {
System.out.println(Thread.currentTgread().egtName());
return arr[i];
});
System.out.println(Arrays.toString(arr));
}
因为多线程的加入，我们之前认识的集合类都废掉了：
public static void main(String[] args) throws InterruptedException {
List<Integer> list = new ArrayList<>();
new Thread(() -> {
for (int i = 0; i < 1000; i++) {
list.add(i); //两个线程同时操作集合类进行插入操作
}
}).start();
new Thread(() -> {
for (int i = 1000; i < 2000; i++) {
list.add(i);
}
}).start();
Thread.sleep(2000);
System.out.println(list.size());
}
因为之前的集合类，并没有考虑到多线程运行的情况，如果两个线程同时执行，那么有可能两个线程同一时间都执行同一个方法，这种情况下就很容易出问题：
public boolean add(E e) {
ensureCapacityInternal(size + 1); // 当数组容量更好还差一个满的时候，这个时候两个线程同时走到了这里，因为都判断为没满，所以说没有进行扩容，但是实际上两个线程都要插入一个元素进来
elementData[size++] = e; //当两个线程同时在这里插入元素，直接导致越界访问
return true;
}
在Java早期的时候，还有一些老的集合类，这些集合类都是线程安全的：
public static void main(String[] args) throws InterruptedException {
Vector<Integer> list = new Vector<>(); //我们可以使用Vector代替List使用
//Hashtable<Integer, String> 也可以使用Hashtable来代替Map
new Thread(() -> {
for (int i = 0; i < 1000; i++) {
list.add(i);
}
}).start();
new Thread(() -> {
for (int i = 1000; i < 2000; i++) {
list.add(i);
}
}).start();
Thread.sleep(1000);
System.out.println(list.size());
}
因为这些集合类中的每一个方法都加了锁，所以说不会出现多线程问题，但是这些老的集合类现在已经不再使用了
548
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
