把知识记在小本本上

将零散的知识点放在一个集中的地方,不断递归重构,形成一套为己所用的知识系统。

博客首页 | 小本本首页

多线程概述

进程

正在运行的程序,是系统进行资源分配和调用的独立单位。

每一个进程都有它自己的内存空间和系统资源。

多进程的意义

单进程计算机只能做一件事情。而现在的计算机都可以一边玩游戏(游戏进程),一边听音乐(音乐进程),所以常见的操作系统都是多进程操作系统。比如:Windows,Mac和Linux等,能在同一个时间段内执行多个任务。

对于单核计算机来讲,游戏进程和音乐进程是同时运行的吗?不是。

因为CPU在某个时间点上只能做一件事情,计算机是在游戏进程和音乐进程间做着频繁切换,且切换速度很快,所以,我们感觉游戏和音乐在同时进行,其实并不是同时执行的。

多进程的作用不是提高执行速度,而是提高CPU的使用率。

线程

是进程中的单个顺序控制流,是一条执行路径。

一个进程如果只有一条执行路径,则称为单线程程序。

一个进程如果有多条执行路径,则称为多线程程序。

多线程的意义

多线程的作用不是提高执行速度,而是为了提高应用程序的使用率。

而多线程却给了我们一个错觉:让我们认为多个线程是并发执行的。其实不是。

因为多个线程共享同一个进程的资源(堆内存和方法区),但是栈内存是独立的,一个线程一个栈。所以他们仍然是在抢CPU的资源执行。一个时间点上只有能有一个线程执行。而且谁抢到,这个不一定,所以,造成了线程运行的随机性。

并行和并发

并行:前者是逻辑上同时发生,指在某一个时间内同时运行多个程序。

并发:后者是物理上同时发生,指在某一个时间点同时运行多个程序。

那么,我们能不能实现真正意义上的并发呢,是可以的,多个CPU就可以实现,不过得知道如何调度和控制它们。

Q & A

Q:Java 程序的运行原理及 JVM 的启动是多线程的吗?

Java 命令去启动 JVM,JVM会启动一个进程,该进程会启动一个主线程。
JVM 的启动是多线程的,因为它最低有两个线程启动了,主线程和垃圾回收线程。

多线程实现

继承 Thread 类

  • 自定义类 MyThread 继承 Thread 类;
  • MyThread 类里面重写 run();
  • 创建对象;
  • 启动线程。

CODE

  • MyThread.java

    1
    2
    3
    4
    5
    6
    7
    8
    public class MyThread extends Thread {
    @Override
    public void run() {
    for (int i = 0; i < 100; i++) {
    System.out.println(getName() + "---" + i);
    }
    }
    }
  • MyThreadTest.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    public class MyThreadTest {
    public static void main(String[] args) {
    MyThread my1 = new MyThread();
    MyThread my2 = new MyThread();

    my1.setName("ahoj");
    my2.setName("baozi");

    my1.start();
    my2.start();

    System.out.println(Thread.currentThread().getName());
    }
    }

Q & A

Q1:为什么是 run() 方法呢?

不是类中的所有代码都需要被线程执行的。这个时候,为了区分哪些代码能够被线程执行,java提供了Thread类中的run()用来包含那些被线程执行的代码。

Q2:线程能不能多次启动(start)?

不可以
通过Thread实例的start(),一个Thread的实例只能产生一个线程。一个Thread的实例一旦调用start()方法,这个实例的started标记就标记为true,事实中不管这个线程后来有没有执行到底,只要调用了一次start()就再也没有机会运行了。
一个线程对象只能调用一次start方法.从new到等待运行是单行道,所以如果你对一个已经启动的线程对象再调用一次start方法的话,会产生:IllegalThreadStateException异常. 可以被重复调用的是run()方法。

Q3:run()和start()方法的区别

run()方法: 在本线程内调用该Runnable对象的run()方法,可以重复多次调用;
start()方法: 启动一个线程,调用该Runnable对象的run()方法,不能多次启动一个线程

Thread 类的方法

1
2
3
4
public final String getName();
public final void setName(String name); // 设置线程名称也可以通过构造的方式

public static Thread currentThread(); // 返回当前正在执行的线程对象

实现 Runnable 接口

步骤:

  • 自定义类MyRunnable实现Runnable接口;
  • 重写run()方法;
  • 创建MyRunnable类的对象;
  • 创建Thread类的对象,并把C步骤的对象作为构造参数传递;
  • 启动线程。

CODE,卖电影票案例

  • SellTickets.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    public class SellTickets implements Runnable{

    private int tickets = 100;

    @Override
    public void run() {
    while (true) {
    if (tickets > 0) {
    try {
    Thread.sleep(100); // 模拟现实中延迟的情况,延迟0.1秒
    System.out.println(Thread.currentThread().getName() + "正在出售第 " + (tickets--) + " 张票");
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    }
    }
    }
    }
  • SellTicketsDemo.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    public class SellTicketsDemo {
    public static void main(String[] args) {
    SellTickets st = new SellTickets();

    Thread t1 = new Thread(st, "窗口1");
    Thread t2 = new Thread(st, "窗口2");
    Thread t3 = new Thread(st, "窗口3");

    t1.start();
    t2.start();
    t3.start();
    }
    }

继承接口的好处

可以避免由于Java单继承带来的局限性。
适合多个相同程序的代码去处理同一个资源的情况,把线程同程序的代码,数据有效分离,较好的体现了面向对象的设计思想。

线程调度和优先级

计算机只有一个 CPU,那么 CPU 在某一个时刻只能执行一条指令,线程只有得到 CPU时间片,也就是使用权,才可以执行指令。那么Java是如何对线程进行调用的呢?

线程调度模型

  • 分时调度模型

    所有线程轮流使用 CPU 的使用权,平均分配每个线程占用 CPU 的时间片。

  • 抢占式调度模型

    优先让优先级高的线程使用 CPU,如果线程的优先级相同,那么会随机选择一个,优先级高的线程获取的 CPU 时间片相对多一些。

Java使用的是抢占式调度模型。

线程的优先级

默认优先级:5

优先级范围:1(低) ~ 10(高)

线程优先级仅代表几率,在多次运行的时候才能看到比较好的效果,1、2次说明不了什么问题。

1
2
public final int getPriority();	// 获取优先级
public final void setPriority(int newPriority); // 设置优先级

线程控制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
线程休眠
public static void sleep(long millis)

线程加入
public final void join():等待该线程终止,为了让某些线程执行完毕别人才可以执行。

线程礼让
public static void yield():暂停正在执行的线程对象,并执行其他线程代码。在一定程度上礼让,但不能保证就是你执行一次我执行一次。

后台线程
public final void setDaemon(boolean on):将线程标记为守护线程或用户线程。
当正在运行的线程都是守护线程时,Java虚拟机退出,该方法必须在启动线程前调用。
举例:坦克大战中的坦克就是守护老巢的守护线程,当老巢报废后,结束!

中断线程
public final void stop():过于暴力,直接停止线程,后面的代码也不会执行。
public void interrupt():把线程的状态终止,并抛出一个异常,后面的代码还会继续执行完。

线程的生命周期

新建、就绪、运行、阻塞、死亡。

线程生命周期

线程安全

线程安全问题在理想状态下,不容易出现,但一旦出现对软件的影响是非常大的。

卖电影票案例出现的问题

为了更符合真实的场景,加入了休眠100毫秒。卖电影票案例

问题1:相同的票出现多次

CPU的一次操作必须是原子性的,例如 ticket– 就不是原子性的操作。

问题2:还出现了负数的票

随机性和延迟导致的

多线程安全问题的原因

  1. 是否有多线程环境
  2. 是否有共享数据
  3. 是否有多条语句操作共享数据

解决多线程安全问题

基本思想:让程序没有安全问题的环境。

把多个语句操作共享数据的代码给锁起来,让任意时刻只能有一个线程执行即可。

解决方案 1 同步代码块

同步代码块,格式如下,这里的 对象 可以是任意的对象,相当于一把钥匙,这个钥匙只能有一把。

1
2
3
synchronized(对象){
需要同步的代码;
}

举个🌰:​​

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class SellTickets implements Runnable {
private int tickets = 100;
private Object obj = new Object();

@Override
public void run() {
while (true) {
synchronized (obj) {
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在出售第 " + (tickets--) + " 张票");
}
}
}
}
}

解决方案 2 同步方法

把同步加在方法上,这里的锁对象是this。

举个🌰:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class SellTickets implements Runnable {

private int tickets = 100;

@Override
public void run() {
while (true) {
sellTickets();
}
}

private synchronized void sellTickets() {
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在出售第 " + (tickets--) + " 张票");
}
}

}

解决方案 3 静态同步方法

把同步加在方法上,这里的锁对象是当前类的字节码文件对象。

举个🌰:此时锁对象是当前类的字节码文件对象 SellTickets.class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class SellTickets implements Runnable {

private static int tickets = 100;

@Override
public void run() {
while (true) {
sellTickets();
}
}

private static synchronized void sellTickets() {
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在出售第 " + (tickets--) + " 张票");
}
}
}

JDK5 中 Lock 锁的使用

虽然我们可以理解同步代码块和同步方法的锁对象问题,但是我们并没有直接看到在哪里加上了锁,在哪里释放了锁,为了更清晰的表达如何加锁和释放锁,JDK5以后提供了一个新的锁对象Lock。

1
2
3
4
// Lock 接口
void lock();
void unlock();
// ReentrantLock 是Lock的实现类

举个🌰:

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 class SellTickets implements Runnable {

private int tickets = 100;

// 定义锁对象
private Lock lock = new ReentrantLock();

@Override
public void run() {
while (true) {
try {
// 加锁
lock.lock();

if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在出售 " + (tickets--) + " 张票");
}
} finally {

// 释放锁
lock.unlock();
}
}
}
}

线程同步的特点

同步的前提:多个线程、多个线程使用的是同一个锁对象

同步的好处:同步的出现解决了多线程的安全问题。

同步的弊端:当线程相当多时,因为每个线程都会去判断同步上的锁,这是很耗费资源的,无形中会降低程序的运行效率。

这就是线程同步,效率低。不同步效率高的解释。

Q & A

Q1:在集合中有一些是线程不安全的集合,当需要使用多线程的时候怎么办?

用Collections工具类的方法把一个线程不安全的集合类变成一个线程安全的集合类。例如:List<String> list1 = Collections.synchronizedList(new ArrayList<String>());

Q2:那么,到底使用谁?

如果锁对象是this,就可以考虑使用同步方法。 否则能使用同步代码块的尽量使用同步代码块。

死锁问题

同步弊端

  • 效率低
  • 如果出现了同步嵌套,就容易产生死锁问题

死锁问题及其代码

  • 是指两个或者两个以上的线程在执行的过程中,因争夺资源产生的一种互相等待现象

举个🌰:

1
2
3
4
5
// MyLock.java
public class MyLock {
public static final Object objA = new Object();
public static final Object objB = new Object();
}
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
// DieLock.java
public class DieLock extends Thread{

private boolean flag;

public DieLock(boolean flag) {
this.flag = flag;
}

@Override
public void run() {
if (flag) {
synchronized (MyLock.objA) {
System.out.println("if objA");
synchronized (MyLock.objB) {
System.out.println("if objB");
}
}
} else {
synchronized (MyLock.objB) {
System.out.println("else objB");
synchronized (MyLock.objA) {
System.out.println("else objA");
}
}
}
}
}
1
2
3
4
5
6
7
8
9
10
// DieLockDemo.java
public class DieLockDemo {
public static void main(String[] args) {
DieLock dl1 = new DieLock(true);
DieLock dl2 = new DieLock(false);

dl1.start();
dl2.start();
}
}

死锁

线程间通信

针对同一个资源的操作有不同种类的线程。

举例:卖票有进的,也有出的。

通过设置线程(生产者)和获取线程(消费者)针对同一个学生对象进行操作。

生产者、消费者

等待唤醒机制

Object 类中提供了三个方法:

1
2
3
wait():等待唤醒,立即释放锁,将来醒过来的时候是从此处醒来。 
notify():唤醒,唤醒并不代表可以立马执行,还必须抢CPU执行权
notifyAll():唤醒所有线程

这些方法的调用,必须通过锁对象来调用。

进程间通信,等待唤醒机制

举个🌰:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// GetThread.java
public class GetThread implements Runnable {

private Student s = new Student();

public GetThread(Student s) {
this.s = s;
}

@Override
public void run() {
while (true) {
synchronized (s) {
s.get();
}
}
}

}
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
// SetThread.java
public class SetThread implements Runnable {

private Student s = new Student();
private int x = 0;

public SetThread(Student s) {
this.s = s;
}

@Override
public void run() {
while (true) {
synchronized (s) {
if (x % 2 == 0) {
s.set("xiaohei", 21);
} else {
s.set("baozi", 20);
}
x++;
}
}
}

}
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
// Student.java
public class Student {
private String name;
private int age;
private boolean flag;

public synchronized void set(String name, int age) {
if (this.flag) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}

this.name = name;
this.age = age;

this.flag = true;
this.notify();
}

public synchronized void get() {
if (!this.flag) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}

System.out.println(this.name + "---" + this.age);
this.flag = false;
this.notify();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// StudentDemo.java
public class StudentDemo {
public static void main(String[] args) {
Student s = new Student();

GetThread gt = new GetThread(s);
SetThread st = new SetThread(s);

Thread t1 = new Thread(gt);
Thread t2 = new Thread(st);

t1.start();
t2.start();
}
}

Q & A

Q:wait()、notify()、notifyAll(),用来操作线程为什么定义在了Object类中?

这些方法存在与同步中。

使用这些方法时必须要标识所属的同步的锁。

锁可以是任意对象,所以任意对象调用的方法一定定义Object类中。

线程组

Java中使用ThreadGroup来表示线程组。

它可以对一批线程进行分类管理,Java允许程序直接对线程组进行控制。

默认情况下,所有的线程都属于主线程组。

1
public final ThreadGroup getThreadGroup();

也可以给线程设置分组

1
Thread(ThreadGroup group, Runnable target, String name);

线程池

程序启动一个新线程成本是比较高的,因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能,尤其是当程序中要创建大量生存期很短的线程时,更应该考虑使用线程池。

线程池里的每一个线程代码结束后,并不会死亡,而是再次回到线程池中成为空闲状态,等待下一个对象来使用。

在JDK5之前,我们必须手动实现自己的线程池,从JDK5开始,Java内置支持线程池。

JDK5新增了一个Executors工厂类来产生线程池,有如下几个方法:

1
2
3
4
5
6
7
public static ExecutorService newCachedThreadPool();
创建一个具有缓存功能的线程池
缓存:百度浏览过的信息再次访问
public static ExecutorService newFixedThreadPool(int nThreads);
创建一个可重用的,具有固定线程数的线程池
public static ExecutorService newSingleThreadExecutor();
创建一个只有单线程的线程池,相当于上个方法的参数是1

这些方法的返回值是ExecutorService对象,该对象表示一个线程池,可以执行Runnable对象或者Callable对象代表的线程。它提供了如下方法:

1
2
Future<?> submit(Runnable task);
<T> Future<T> submit(Callable<T> task);

线程池的好处:线程池里的每一个线程代码结束后,并不会死亡,而是再次回到线程池中成为空闲状态,等待下一个对象来使用。

1
2
3
4
5
6
7
8
9
10
11
// ExecutorsDemo.java
public class ExecutorsDemo {
public static void main(String[] args) {
ExecutorService pool = Executors.newFixedThreadPool(2); // 创建Runnable实例

pool.submit(new MyRunnable()); // 提交Runnable实例
pool.submit(new MyRunnable()); // 提交Runnable实例

pool.shutdown(); // 关闭线程池
}
}
1
2
3
4
5
6
7
8
9
// MyRunnable.java
public class MyRunnable implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}

匿名内部类方式使用多线程

匿名内部类方式使用多线程

1
2
3
4
5
6
7
new Thread() {
代码…
}.start();

new Thread(new Runnable() {
代码…
}).start();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
new Thread() {
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println(getName() + "---" + x);
}
};
}.start();

new Thread(new Runnable() {
@Override
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println(Thread.currentThread().getName() + "---" + x);
}
}
}).start();

定时器

定时器是一个应用十分广泛的线程工具,可用于调度多个定时任务以后台线程的方式执行。在Java中,可以通过Timer和TimerTask类来实现定义调度的功能。

1
2
3
4
5
6
7
8
// Timer
public Timer();
public void schedule(TimerTask task, long delay);
public void schedule(TimerTask task,long delay,long period);

// TimerTask
public abstract void run()
public boolean cancel()

开发中,Quartz是一个完全由java编写的开源调度框架。