Java多线程编程

Java多线程编程

线程概念

线程概念：

一个线程就是一个 “执行流”. 每个线程之间都可以按照顺讯执行自己的代码. 多个线程之间 “同时” 执行
着多份代码

线程作用：

在多核CPU情况下，充分利用CPU资源；对于需要等待IO的任务，利用CPU资源

在创建，销毁，调度上相比进程更加轻量

进程和线程的区别：

进程是包含线程的，每个进程至少有一个线程存在，即主线程

进程和进程之间不共享内存空间，同一个进程的线程之间共享同一个内存空间

进程是系统分配资源的最小单位，线程是系统调度的最小单位

线程常用方法

Thread 类是 JVM 用来管理线程的一个类，换句话说，每个线程都有一个唯一的 Thread 对象与之关
联

构造方法：

属性方法：

注：优先级高的线程理论上来说更容易被调度到；JVM会在一个进程的所有非后台线程结束后，才会结束运行

启动线程：

t.start();//调用 start 方法, 才真的在操作系统的底层创建出一个线程
1

获取当前线程引用：

休眠当前线程：

线程创建

继承Thread类：

public class ThreadDemo extends Thread {
    @Override
    public void run() {
        System.out.println("hello world");
    }

    public static void main(String[] args) {
        ThreadDemo t = new ThreadDemo();
        t.start();//创建线程+调用run()
        System.out.println("nihao");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

实现Runnable接口：

public class Thread2 implements Runnable{
    @Override
    public void run() {
        System.out.println("hello world");
    }
    public static void main(String[] args) {
        Thread t = new Thread(new Thread2());
        t.start();//创建线程+调用run()
        System.out.println("nihao");
    }
}
1
2
3
4
5
6
7
8
9
10
11

匿名内部类Thread子类：

    public static void main(String[] args) {
        Thread t = new Thread(){
            @Override
            public void run() {
                System.out.println("hello world");
            }
        };
        t.start();
        System.out.println("nihao");
    }
1
2
3
4
5
6
7
8
9
10

匿名内部类Runnable子类：

    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello world");
            }
        });
        t.start();
        System.out.println("nihao");
    }
1
2
3
4
5
6
7
8
9
10

lambda表示式创建Runnable子类：

    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("hello world");
        });
        t.start();
        System.out.println("nihao");
    }
1
2
3
4
5
6
7

线程优先级

Java采用的是抢占式调度方式，优先级越高的线程，优先使用CPU资源

我们希望CPU花费更多的时间去处理更重要的任务，而不太重要的任务，则可以先让出一部分资源。

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

• MIN_PRIORITY 最低优先级
• MAX_PRIORITY 最高优先级
• NOM_PRIORITY 常规优先级

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

终止线程

1. 通过共享的标记来进行沟通

public class ThreadDemo {
    public static volatile boolean isQuit = false;//volatile保证内存可见性

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
                while (!isQuit) {//自动捕获‘final’属性的变量
                    System.out.println(Thread.currentThread().getName()
                            + ": hello worold!");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName()
                        + ": out of while");
        }, "李四");
        System.out.println(Thread.currentThread().getName()
                + ": start。");
        thread.start();
        Thread.sleep(10 * 1000);
        System.out.println(Thread.currentThread().getName()
                + ": down！");
        isQuit = true;
    }
}
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

2. 调用 interrupt() 方法来通知

使用 Thread.interrupted() 或者 Thread.currentThread().isInterrupted() 代替自定义标志位

public class test1 {
    static class MyRunnable implements Runnable {
        @Override
        public void run() {
            while(!Thread.interrupted()){
                System.out.println("working---");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    //选择处理方式
                    break;
                }
            }
        }
    }
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();
        Thread t = new Thread(mr);
        t.start();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("thread interrupted");
        t.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

thread 收到通知的方式有两种：

1. 如果线程因为调用 wait/join/sleep 等方法而阻塞挂起，则以 InterruptedException 异常的形式通
   知，清除中断标志；当出现 InterruptedException 的时候, 要不要结束线程取决于 catch 中代码的写法. 可以选择忽略这个异常, 也可以跳出循环结束线程
2. 如果线程正在工作，则只是内部的一个中断标志被设置；Thread.interrupted() 判断当前线程的中断标志被设置，清除中断标志Thread.currentThread().isInterrupted() 判断指定线程的中断标志被设置，不清除中断标志

等待线程

有时需要等待一个线程完成它的工作后，才能进行自己的下一步工作。

public class test2 {
    public static void main(String[] args) throws InterruptedException {
        Runnable r = () -> {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName()+" working...");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName() + "work finish");
        };
        Thread t1 = new Thread(r, "zhangsan");
        Thread t2 = new Thread(r, "lisi");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

线程状态

线程的状态是一个枚举类型 Thread.State

public class ThreadState {
    public static void main(String[] args) {
        for (Thread.State state : Thread.State.values()) {
            System.out.println(state);
        }
    }
}
1
2
3
4
5
6
7

NEW: 安排了工作, 还未开始行动
RUNNABLE: 可工作的. 又可以分成正在工作中和即将开始工作.
BLOCKED: 这几个都表示排队等着其他事情，被锁给阻塞住了
WAITING: 这几个都表示排队等着其他事情，被wait()给阻塞住了
TIMED_WAITING: 这几个都表示排队等着其他事情，被sleep()给阻塞住了
TERMINATED: 工作完成了
1
2
3
4
5
6

状态转移图：

BLOCKED 表示等待获取锁

WAITING 和 TIMED_WAITING 表示等待其他线程发来通知

TIMED_WAITING 线程在等待唤醒，但设置了时限

WAITING 线程在无限等待唤醒

相关函数：

yield();//让出cpu，yield 不改变线程的状态, 但是会重新去排队
isAlive();//判断线程的存活状态
1
2

线程安全

多线程环境下代码运行的结果是符合我们预期的，即在单线程环境应该的结果，则说这个程序是线
程安全的。

修改共享数据：

多个线程针对 counter.count 变量进行修改，此时这个 counter.count 是一个多个线程都能访问到的 “共享数据”

原子性：

原子性表示一个资源在同一时间段下只有一个访问资源者进行操作

有时也把这个现象叫做同步互斥，表示操作是互相排斥的

一条 java 语句不一定是原子的，因为语句不一定包含的可能不只是一条指令

数据自增1底层操作步骤：

1. 从内存把数据读到 CPU

2. 进行数据更新

3. 把数据写回到 CPU

synchronized

synchronized 是一个互斥锁, 某个线程执行到某个对象的 synchronized 中时, 其他线程如果也执行到
同一个对象 synchronized 就会阻塞等待。

synchronized用的锁是存在Java对象头里的，synchronized的底层是使用操作系统的mutex lock实现的。

synchronized上锁是需要传入对象的，当对象不同时，获取到的是不同的锁，因此并不能保证自增操作的原子性。

public class SynchronizedDemo {
    public void method() {
        synchronized (this) {//锁当前对象
        }
    }
}
1
2
3
4
5
6

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

private static int value = 0;

private static synchronized void add(){
    value++;
}
1
2
3
4
5

如果是静态方法，就是使用的类锁，而如果是普通成员方法，就是使用的对象锁。通过灵活的使用synchronized就能很好地解决线程安全的问题。

synchronized 的工作过程:

1. 获得互斥锁

2. 从主内存拷贝变量的最新副本到工作的内存

3. 执行代码

4. 将更改后的共享变量的值刷新到主内存

5. 释放互斥锁

synchronized 同步块对同一条线程来说是可重入的，不会出现自己把自己锁死的问题

在可重入锁的内部, 包含了 “线程持有者” 和 “计数器” 两个信息：

如果某个线程加锁的时候, 发现锁已经被人占用, 但是恰好占用的正是自己, 那么仍然可以继续获取
到锁, 并让计数器自增

解锁的时候计数器递减为 0 的时候, 才真正释放锁. (才能被别的线程获取到)

volatile

volatile 修饰的变量, 能够保证 “内存可见性”

直接访问工作内存(实际是 CPU 的寄存器或者 CPU 的缓存), 速度非常快, 但是可能出现数据不一致的情况。变量加上 volatile 关键字修饰, 强制读写内存，速度是慢了, 但是数据变的更准确了。

代码在写入 volatile 修饰的变量的时候：

1. 改变线程工作内存中volatile变量副本的值
2. 将改变后的副本的值从工作内存刷新到主内存

代码在读取 volatile 修饰的变量的时候：

1. 从主内存中读取volatile变量的最新值到线程的工作内存中
2. 从工作内存中读取volatile变量的副本

wait和notify方法

wait()、notify()以及notifyAll()是需要配合synchronized来使用的（实际上锁就是依附于对象存在的，每个对象都应该有针对于锁的一些操作）。

对象的wait()方法会暂时使得此线程进入等待状态，同时会释放当前代码块持有的锁，这时其他线程可以获取到此对象的锁。

当其他线程调用对象的notify()方法后，会唤醒刚才变成等待状态的线程（必须是在持有锁（同步代码块内部）的情况下使用，否则会抛出异常）。

notifyAll其实和notify一样，也是用于唤醒，但是前者是唤醒所有调用wait()后处于等待的线程，而后者是看运气随机选择一个。

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();
}
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

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

线程中创建的子线程，无法获得父线程工作内存中的变量，使用InheritableThreadLocal来解决：

public static void main(String[] args) {
    ThreadLocal<String> local = new InheritableThreadLocal<>();
    Thread t = new Thread(() -> {
       local.set("lbwnb");
        new Thread(() -> {
            System.out.println(local.get());
        }).start();
    });
    t.start();
}
1
2
3
4
5
6
7
8
9
10

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

标准库线程安全类

Java 标准库中很多都是线程不安全的. 这些类可能会涉及到多线程修改共享数据, 又没有任何加锁措施:

1. ArrayList
2. LinkedList
3. HashMap
4. TreeMap
5. HashSet
6. TreeSet
7. StringBuilder

使用了一些锁机制来保证线程安全的类：

1. Vector (不推荐使用)
2. HashTable (不推荐使用)
3. ConcurrentHashMap
4. StringBuffer

不涉及 “修改”, 仍然是线程安全的：

1. String
   (() -> {
   local.set(“lbwnb”);
   new Thread(() -> {
   System.out.println(local.get());
   }).start();
   });
   t.start();
   }

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

## 标准库线程安全类  

Java 标准库中很多都是线程不安全的. 这些类可能会涉及到多线程修改共享数据, 又没有任何加锁措施:

1. ArrayList
2. LinkedList
3. HashMap
4. TreeMap
5. HashSet
6. TreeSet
7. StringBuilder  

使用了一些锁机制来保证线程安全的类：

1. Vector (不推荐使用)
2. HashTable (不推荐使用)
3. ConcurrentHashMap
4. StringBuffer  

不涉及 "修改", 仍然是线程安全的：

1. String  
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