[JAVA]线程

发表于 更新于 收录于
线程

创建线程

通过创建Thread对象来创建一个新的线程，Thread构造方法中需要传入一个Runnable接口的实现（其实就是编写要在另一个线程执行的内容逻辑）同时Runnable只有一个未实现方法，因此可以直接使用lambda表达式：

1
2
3
4
5
6
public static void main(String[] args) {
    Thread t = new Thread(() -> {    //直接编写逻辑
        System.out.println("我是另一个线程！");
    });
    t.start();   //调用此方法来开始执行此线程
}

  • run与start的区别：run是在当前线程执行，并不是创建一个线程执行。

线程的休眠和中断

一个线程处于运行状态下，线程的下一个状态会出现以下情况：

  • 1.当CPU给予的运行时间结束时，会从运行状态回到就绪（可运行）状态，等待下一次获得CPU资源。
  • 2.当线程进入休眠 / 阻塞(如等待IO请求) / 手动调用wait()方法时，会使得线程处于等待状态，当等待状态结束后会回到就绪状态。
  • 3.当线程出现异常或错误 / 被stop() 方法强行停止 / 所有代码执行结束时，会使得线程的运行终止。

而这个部分我们着重了解一下线程的休眠和中断，首先我们来了解一下如何使得线程进如休眠状态：

1
2
3
4
5
6
7
8
9
10
11
12
public static void main(String[] args) {
    Thread t = new Thread(() -> {
        try {
            System.out.println("l");
            Thread.sleep(1000);   //sleep方法是Thread的静态方法，它只作用于当前线程（它知道当前线程是哪个）
            System.out.println("b");    //调用sleep后，线程会直接进入到等待状态，直到时间结束
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
    t.start();
}

  • 通过调用sleep()方法来将当前线程进入休眠，使得线程处于等待状态一段时间。
  • 此方法显示声明了会抛出一个InterruptedException异常，那么这个异常在什么时候会发生呢？
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    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()呢，因为stop()会导致资源不能完全释放。假设线程正在读一个文件，线程调用stop()会导致操作终止，不会处理任何事情，此时文件不会被close，会导致资源占用。
  • interrupt的用法：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
        public static void main(String[] args){
            Thread t = new Thread(() -> {
                while(true){
                    if(Thread.currentThread().isInterrupted()){
                        System.out.println("我被打了中断标记，需要切换到下一个循环");
                        break;
                    }
                }
                Thread.interrupted();//复原中断标记
                while(true){
                    if(Thread.currentThread().isInterrupted()){
                        System.out.println("我被打了中断标记，需要立即停止");
                        break;
                    }
                }
                System.out.println("我是结束之后的操作");

            });

            t.start();
            try {
                Thread.sleep(3000);
                t.interrupt();
                Thread.sleep(3000);
                t.interrupt();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }

    out:
    我被打了中断标记，需要切换到下一个循环
    我被打了中断标记，需要立即停止
    我是结束之后的操作
    我们希望线程暂时停下，比如等待其他线程执行完成后，再继续运行，那这样的操作怎么实现呢？
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    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();
        }
    }

    out:
    线程开始运行！
    线程继续运行！
  • 虽然这样很方便地控制了线程的暂停状态，但是这两个方法我们发现实际上也是不推荐的做法，它很容易导致死锁！有关为什么被弃用的原因，我们会在线程锁继续探讨。

线程的优先级

Java程序中的每个线程并不是平均分配CPU时间的，为了使得线程资源分配更加合理，Java采用的是抢占式调度方式，优先级越高的线程，优先使用CPU资源。

线程的优先级一半分为以下三种：

  • MIN_PRIORITY 最低优先级
  • MAX_PRIORITY 最高优先级
  • NOM_PRIORITY 常规优先级
    1
    2
    3
    4
    5
    6
    7
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("线程开始运行！");
        });
        t.start();
        t.setPriority(Thread.MIN_PRIORITY);  //通过使用setPriority方法来设定优先级
    }

线程的礼让加入

我们可以在当前线程的工作不重要时，将CPU资源让位给其他线程，通过yield()方法来将当前资源让位给其他同级优先级线程：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
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();
}
out:
线程1开始运行！
让位！
线程2开始运行！
1打印：0
1打印：1
1打印：2
1打印：3
1打印：4
让位！
2打印：0
2打印：1
2打印：2
2打印：3
2打印：4
2打印：5
2打印：6
2打印：7
2打印：8
2打印：9
线程2结束
1打印：5
1打印：6
1打印：7
1打印：8
1打印：9
线程1结束

观察结果，我们发现，在让位之后，尽可能多的在执行线程2的内容。

当我们希望一个线程等待另一个线程执行完后再继续进行，我们可以使用join()的方法实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
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(i == 10){
                try {
                    System.out.println("线程1加入到此线程！");
                    t1.join();    //在i==10时，让线程1加入，先完成线程1的内容，在继续当前内容
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    });
    t1.start();
    t2.start();
}

out:
线程1开始运行！
线程2开始运行！
1打印：0
2打印：0
1打印：1
2打印：1
2打印：2
2打印：3
1打印：2
2打印：4
1打印：3
2打印：5
1打印：4
线程1加入到此线程
1打印：5
1打印：6
1打印：7
1打印：8
1打印：9
线程1结束
2打印：6
2打印：7
2打印：8
2打印：9
线程2结束

  • 我 们发现，线程1加入后，线程2等待线程1代执行的内容全部执行完成之后，再继续执行线程2的内容。
  • 注意，线程的加入只是等待另一个线程的完成，并不是将另一个线程和当前的线程合并！

线程锁和线程同步

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 private static int i = 0;

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
           for(int j = 0; j < 100000; j++){
               i++;
           }
        }).start();

        new Thread(() -> {
            for(int j = 0; j < 100000; j++){
                i++;
            }
        }).start();

        Thread.sleep(1000);
        System.out.println(i);
    }
out:
122794

我们发现输出并不是200000。

  • 线程中的共享变量存储在主内存中，每个线程都有一个私有的工作内存，工作内存存储了该线程以读/写共享变量的副本。类似于多核心处理器高速缓存机制。操作完后会重新写到主内存中，

  • 高速缓存通过保存内存中数据的副本来提供更加快速的数据访问。

  • 但是如果多个处理器的运算任务都涉及同一区域，就可能导致各自的高速缓存数据不一致，在写回主内存时就会发生冲突。

  • 这就是引入高速缓存引发的新问题，称之为：缓存一致性。

  • 实际上Java的内存模型也是这样设计的，当我们同时去操作一个共享变量时，如果仅仅是读取还好，但如果同时写入内容，就会产生问题。

  • 好比一个银行，如果我和我的朋友同时在银行取我账户里面的钱，难道取1000还可能吐2000出来吗？我们需要一种更加安全的机制来维持秩序，保证数据的安全性！

  • 这样子就可以解释上面的问题，两个线程同时读取i时，可能回同时拿到同样的值，而进行自增操作后，也是同样的值，再写回主内存时，本来应该进行2次自增操作，实际上只执行了一次！

  • 我们可以通过synchronized来创建一个线程锁。通过加锁的方法让同一时间只能执行这个代码里的内容。

  • 我们来认识一下synchronized代码块，它需要在括号中填入一个内容，必须是一个对象或是一个类，我们在value自增操作外套上同步代码块：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    private static int value = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                synchronized (Main.class){  //使用synchronized关键字创建同步代码块
                    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);  //主线程停止1秒，保证两个线程执行完成
        System.out.println(value);
    }

    out:
    线程2完成！
    线程1完成！
    20000

  • 在同步代码块执行的过程中，拿到了我们传入对象或类的锁(传入的如果是对象，就是对象锁，不同的对象代表不同的对象锁，如果是类，就是类锁，类锁只有一个，实际上类锁也是对象锁，是Class类实例，但是Class类实例同样的类无论怎么获取都是同一个)，但是注意两个线程必须使用同一把锁。

  • 当一个线程进入到同步代码快时，会获取到当前的锁。

  • 而这是如果其他使用同样的锁的同步代码块也想执行内容，就必须等待当前同步代码块的内容执行完成，在执行完成后会自动释放这把锁，而其他线程才能拿到这把锁并开始执行同步代码块里面的内容。
  • 实际上synchronized是一种悲观锁，随时都认为有其他线程在对数据进行修改。

如果我们使用的是不同对象的锁，就不能顺利运行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
private static int value = 0;

public static void main(String[] args) throws InterruptedException {
    Main main1 = new Main();
    Main main2 = new Main();
    Thread t1 = new Thread(() -> {
        for (int i = 0; i < 10000; i++) {
            synchronized (main1){
                value++;
            }
        }
        System.out.println("线程1完成");
    });
    Thread t2 = new Thread(() -> {
        for (int i = 0; i < 10000; i++) {
            synchronized (main2){
                value++;
            }
        }
        System.out.println("线程2完成");
    });
    t1.start();
    t2.start();
    Thread.sleep(1000);  //主线程停止1秒，保证两个线程执行完成
    System.out.println(value);
}

out:
168324

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
ublic static void main(String[] args) throws InterruptedException {

        Object o = new Object();

        Thread t1 = new Thread(() -> {
            System.out.println("线程1开始！");
            synchronized (o){
                for(int i = 0; i < 5; i++){
                    try {
                        System.out.println("线程1正在运行...");
                        Thread.sleep(1000);
                    }catch (InterruptedException e){
                        throw new RuntimeException(e);
                    }
                }
            }
            System.out.println("线程1结束");
        });
        Thread t2 = new Thread(() -> {
            System.out.println("线程2开始！");
            synchronized (o){
                for(int i = 0; i < 5; i++){
                    try {
                        System.out.println("线程2正在运行...");
                        Thread.sleep(1000);
                    }catch (InterruptedException e){
                        throw new RuntimeException(e);
                    }
                }
            }
            System.out.println("线程2结束");
        });
        t1.start();
        t2.start();
    }
out:
线程1开始！
线程1正在运行...
线程2开始！
线程1正在运行...
线程1正在运行...
线程1正在运行...
线程1正在运行...
线程1结束
线程2正在运行...
线程2正在运行...
线程2正在运行...
线程2正在运行...
线程2正在运行...
线程2结束

  • synchronized关键字也可以作用于方法上，调用此方法时也会获取锁：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    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);
    }


  • 我们发现实际上效果是相同的，只不过这个锁不用你去给，如果是静态方法，就是使用的类锁，而如果是普通成员方法，就是使用的对象锁。通过灵活的使用synchronized就能很好地解决我们之前提到的问题了。

死锁

  • 指两个线程相互持有对方需要的锁，但是又迟迟不释放，导致程序卡住：

  • 线程A持有锁A但试图获取锁B

  • 线程B持有锁B但试图获取锁A

  • 这样就对导致线程A和线程B都需要对方的锁，但是又被对方牢牢把握，由于现场被无限期地阻塞，因此程序不可能正常终止。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    public static void main(String[] args) throws InterruptedException {

            Object o1 = new Object();
            Object o2 = new Object();

            Thread t1 = new Thread(() -> {
                synchronized (o1){
                    System.out.println("线程1拿到锁1");
                    try {
                        Thread.sleep(1000);
                        System.out.println("线程1等待锁2");
                        synchronized (o2){
                            System.out.println("线程1");
                        }
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
            });
            Thread t2 = new Thread(() -> {
                synchronized (o2){
                    System.out.println("线程2拿到锁2");
                    try {
                       Thread.sleep(1000);
                        System.out.println("线程2等待锁1");
                       synchronized (o1){
                           System.out.println("线程2");
                       }
                   }catch (InterruptedException e){
                       e.printStackTrace();
                   }
                   }
            });
            t1.start();
            t2.start();
        }
    out:
    线程1拿到锁1
    线程2拿到锁2
    线程1等待锁2
    线程2等待锁1

  • 编写程序时，一定要避免。

  • 可以使用jstack检测是否出现死锁。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    (base) linguole@linguole test % jps
    2937 
    7177 Launcher
    7178 Main
    7195 Jps
    (base) linguole@linguole test % jstack 7178
    Found one Java-level deadlock:
    =============================
    "Thread-0":
      waiting to lock monitor 0x00007fce61413e00 (object 0x000000070feddf70, a java.lang.Object),
      which is held by "Thread-1"
    "Thread-1":
      waiting to lock monitor 0x00007fce61413d00 (object 0x000000070feddf60, a java.lang.Object),
      which is held by "Thread-0"

    Java stack information for the threads listed above:
    ===================================================
    "Thread-0":
            at com.test.Main.lambda$main$0(Main.java:17)
            - waiting to lock <0x000000070feddf70> (a java.lang.Object)
            - locked <0x000000070feddf60> (a java.lang.Object)
            at com.test.Main$$Lambda$14/0x0000000800066840.run(Unknown Source)
            at java.lang.Thread.run(java.base@11.0.18/Thread.java:829)
    "Thread-1":
            at com.test.Main.lambda$main$1(Main.java:31)
            - waiting to lock <0x000000070feddf60> (a java.lang.Object)
            - locked <0x000000070feddf70> (a java.lang.Object)
            at com.test.Main$$Lambda$15/0x0000000800066c40.run(Unknown Source)
            at java.lang.Thread.run(java.base@11.0.18/Thread.java:829)

  • 前面说不推荐使用suspend()去挂起线程的原因，是因为suspend()在使线程暂停的同时，并不会去释放任何锁资源。

  • 其他线程仍无法访问被他占用的锁。
  • 直到对应线程执行resume()后，被挂起的资源才能继续，从而其他被阻塞在这个锁的线程才可以继续执行。
  • 但是，如果resume()初夏在suspend()之前，那么线程将一直处于挂起状态，同时一直占用锁，这就产生了死锁。

wait和notify方法

wait(),notify(),和NotifyAll()需要配合synchronized来使用（实际上锁就是依附于对象存在的，每个对象都应该有针对于锁的一些操作，所以说就这样设计了）。当然，只有在同步代码块中才能使用这些方法，正常情况下会报错，我们来看看他们的作用是什么：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public static void main(String[] args) throws InterruptedException {
    Object o1 = new Object();
    Thread t1 = new Thread(() -> {
        synchronized (o1){
            try {
                System.out.println("线程开始");
                Thread.sleep(1000);
                System.out.println("开始等待");
                o1.wait();     //进入等待状态并释放锁
                System.out.println("线程1结束");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
    Thread t2 = new Thread(() -> {
        synchronized (o1){
            System.out.println("我拿到锁了！");
            o1.notify();     //唤醒处于等待状态的线程
          	try{
                Thread.sleep(1000);
            }cath(InterruptedException e){
                throw new RuntimeEception(e);
            }
            System.out.println("线程2结束"); 
        }
    });
    t1.start();
    Thread.sleep(1000);
    t2.start();
}
out:
线程开始
开始等待
我拿到锁了！
线程2结束
线程1结束

  • wait()会暂时使得线程进入等待状态，同时释放当前代码块持有的锁，只是其他线程就可以获取到此对象的锁。
  • 当其他线程调用对象botify()后，会唤醒刚才变成等待状态的线程(这时并没有有立即释放锁).
  • notifyAll其实和notify一样，也是用于唤醒，但是前者是唤醒所有调用wait()后处于等待的线程，而后者是看运气随机选择一个。
  • wait(timeout):timout自动唤醒

ThreadLock

  • 既然每个线程都有一个自己的工作内存，那么能否只在自己的工作内存中创建变量仅供线程自己使用呢

  • 我们可以使用ThreadLock类，来创建工作内存中的变量，它将我们的变量值存储在内部(只存储一个变量)，不同的线程访问到ThreadLocal对象时，都只能获取到当前线程所属的变量。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    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();
    }

    out:
    变量已设定
    lbwnb
    null

  • 开启两个线程分别去访问ThreadLocal对象。

  • 第一个线程存放的内容，第一个线程可以获取。

  • 第二个线程无法获取。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    public static void main(String[] args) throws InterruptedException {

            ThreadLocal<String> local = new ThreadLocal<>();
            Thread t1 = new Thread(() -> {
                local.set("lbwnb");
                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");
                System.out.println("线程2变量已设定：");
                System.out.println(local.get());
            });
            t1.start();
            Thread.sleep(1000);
            t2.start();
        }

    out:
    线程1变量已设定
    线程2变量已设定：
    yyds
    线程1读取变量：
    lbwnb

  • 即使线程2重新设定了值，也没有影响到线程1存放的值。

  • 不同线程向ThreadLocal存放数据，只会存放在线程自己的工作空间中，而不会存放到主内存中，因此各个线程直接存放的内容互不干扰。

线程中创建的子线程，无法获得父线程工作内存中的变量：

1
2
3
4
5
6
7
8
9
10
11
ThreadLocal<String> local = new ThreadLocal<>();
        Thread t1 = new Thread(() -> {
            local.set("lbwnb");
           new Thread(() -> {
               System.out.println(local.get());
           }).start();
        });
        t1.start();

out:
null

可以使用InheritableThreadLoca来解决：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static void main(String[] args) throws InterruptedException {

        ThreadLocal<String> local = new InheritableThreadLocal<>();
        Thread t1 = new Thread(() -> {
            local.set("lbwnb");
           new Thread(() -> {
               System.out.println(local.get());
           }).start();
        });
        t1.start();
    }

out:
lbwnb

  • 在InheritableThreadLocal存放的内容，会自动向子线程传递。

定时器

1
2
3
4
5
6
7
8
9
10
11
public static void main(String[] args) throws InterruptedException {
        Timer timer = new Timer();    //创建定时器对象
        timer.schedule(new TimerTask() {   //注意这个是一个抽象类，不是接口，无法使用lambda表达式简化，只能使用匿名内部类
            @Override
            public void run() {
                System.out.println("我是延迟任务");    //打印当前线程名称
            }
        }, 1000, 1000);    //执行一个延时任务
        Thread.sleep(1000);
        timer.cancel();
    }
  • 通过创建一个Timer类来让它进行定时任务调度。
  • 通过此对象来创建任意类型的定时任务，包括延时任务、循环定时任务等。
  • 可以使用timer.cancel()中止任务。

  • 虽然任务执行完成了，但是我们的程序并没有停止，这是因为Timer内存维护了一个任务队列和一个工作线程：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    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，是一个新创建的线程，在构造时自动启动：

    1
    2
    3
    4
    public Timer(String name) {
        thread.setName(name);
        thread.start();
    }

  • run方法会循环地去读队列中是否还有任务

  • 如果有任务一次执行，没有的话就处于休眠状态：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    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;    //当被唤醒后都没有任务时，就会结束循环，也就是结束工作线程
                          ...
    }

守护线程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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);
    }
}
  • 守护线程在后台运行，不需要和用户交互，本质和普通进程类似。
  • 而守护线程就不一样了，当其他所有的非守护线程结束之后，守护线程自动结束。
  • Java中所有的线程都执行完毕后，守护线程自动结束，因此守护线程不适合进行IO操作，只适合打打杂。

再谈集合类

  • 可拆分迭代器（Splitable Iterator）和Iterator一样，Spliterator也用于遍历数据源中的元素，但它是为了并行执行而设计的。

  • 在集合跟接口Collection中提供了一个spliterator()方法用于获取可拆分迭代器。

    1
    2
    3
    default Stream<E> parallelStream() {
        return StreamSupport.stream(spliterator(), true); //parallelStream就是利用了可拆分迭代器进行多线程操作
    }

  • 并行流，其实就是一个多线程执行的流，它通过默认的ForkkJoinPool实现，可以提高多线程的速度：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    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));
    }
    out:
    ForkJoinPool.commonPool-worker-7 -> 9
    main -> 3
    ForkJoinPool.commonPool-worker-5 -> 0
    ForkJoinPool.commonPool-worker-15 -> 6
    ForkJoinPool.commonPool-worker-13 -> 1
    ForkJoinPool.commonPool-worker-9 -> 3
    ForkJoinPool.commonPool-worker-3 -> 5
    ForkJoinPool.commonPool-worker-11 -> 2

  • 我们发现，forEach操作的顺序，并不是我们实际List中的顺序，同时每次打印也是不同的线程在执行！

  • 在Arrays数组工具类中，也包含大量的并行方法：

    1
    2
    3
    4
    5
    6
    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));
    }

  • 更多地使用并行方法，可以更加充分地发挥现代计算机多核心的优势，但是同时需要注意多线程产生的异步问题！

  • 因为多线程的加入，前面的集合类会出现问题：

线程安全的方法

Java中的线程安全是指在多线程并发执行的情况下，对共享的数据进行操作时，不会产生意外的结果，保证程序的正确性。

当多个线程同时访问共享资源时，可能会出现以下问题：

  • 1.竞态条件(Race Condition)：多个线程同时对同一个数据进行读写，导致数据的值不确定。
  • 2.死锁(DeadLock)：两个或多个相互等待对方释放资源，导致程序无法继续执行。
  • 3.数据不一致(Inconsistent Data)：多个线程同时修改同一个数据，导致数据的值不一致。

在Java中，可以通过以下方式来实现线程安全：

  • 1.使用synrchronized关键字：ynrchronized可以保证同一时间只有一个线程执行关键代码段，从而避免多个线程同时访问共享资源的问题。
  • 2.使用Lock接口：Lock接口时Java5中新增的一个借口，它提供了比ynrchronized更灵活的锁定机制，可以控制锁的获取和释放。
  • 3.使用线程安全的集合类：
    • ConcurrentHashMap：线程安全的HashMap，可以在多线程环境下高效的进行读写操作。
    • ConcurrentLinkedQueue：线程安全的队列，支持多线程并发访问。
    • CopyOnWeiteArrayList：线程安全的动态数组，每次修改都会复制一份新的数据，保证并发访问的安全性。
    • CopyOnWeiteArraySet：线程安全的集合，基于CopyOnWeiteArrayList实现。
    • ConcurrentSkpiListMap：线程安全的Map，使用跳表(Skip List)实现，支持高贤的多线程并发访问。
    • ConcurrentSkpiListSet：线程安全的有序集合，基于ConcurrentSkpiListMap实现。