1.线程相关概念

（1）程序
程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。简单的说就是我们写的代码。
（2）进程
①进程是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；
②进程也是程序的一次执行过程，它是一个动态的概念，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。（比如我们使用的QQ，就启动了一个进程，操作系统就会为该进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统将为迅雷分配新的内存空间。）
（3）线程
线程是由进程创建的，是进程的一个实体;一个进程可以拥有多个线程。例如：使用浏览器同时下载多个文件，就是一个进程有多个线程。
①单线程
同一个时刻，只允许执行一个线程
②多线程
同一个时刻，可以执行多个线程，比如：一个qq进程，可以同时打开多个聊天窗口
（4）管程
管程俗称Monitor(监视器)，也就是我们平时所说的锁。

（5）并发
同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单的说，单核cpu实现的多任务就是并发。

（6）并行
同一个时刻，多个任务同时执行。多核cpu可以实现并行。

2.线程的基本使用

2.1 创建线程的方式

（1）继承Thread类，重写run方法

// 创建线程对象,构造方法的参数是给线程指定名字，推荐
Thread t1 = new Thread("t1") {
	@Override
	// run 方法内实现了要执行的任务
	public void run() {
		log.debug("hello");
} };
t1.start();
1
2
3
4
5
6
7
8

（2)使用 Runnable 配合 Thread
把【线程】和【任务】（要执行的代码）分开
①Thread 代表线程
②Runnable 可运行的任务（线程要执行的代码）

// 创建任务对象
Runnable task2 = new Runnable() {
	@Override
	public void run() {
		log.debug("hello");
} };
// 参数1 是任务对象; 参数2 是线程名字，推荐
Thread t2 = new Thread(task2, "t2");
t2.start();
1
2
3
4
5
6
7
8
9

补充：Thread 与 Runnable 的关系
①继承Thread类是把线程和任务合并在了一起，使用 Runnable 配合 Thread是把线程和任务分开了
②用 Runnable 更容易与线程池等高级 API 配合
③用 Runnable 让任务类脱离了 Thread 继承体系，更灵活
④Java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时再用继承Thread类方法来实现创建线程显然不可能了。
⑤Java设计者提供了另外一种创建线程的方法，就是通过实现Runnable接口来创建线程。实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制，建议使用Runnable

（3）FutureTask 配合 Thread

Callable与Runnable区别是有返回值，可以抛异常

例子：

public class DemoFutureTask {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
       FutureTask<Integer> task = new FutureTask<>(new Callable<Integer>() {
           @Override
           public Integer call() throws Exception {
               return 100;
           }
       });
        Thread t1 = new Thread(task,"t1");
        t1.start();
        System.out.println(task.get()); //100

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2.2 通知线程退出

（1）当线程退出后,会自动退出
（2）还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式

public class Thread_exit {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        t.start();
//        如果希望main线程去控制t1 线程的终止，可以修改 loop
//        让t1 退出run方法，从而终止 t1线程 -> 通知方式
//        让主线程休眠 10秒，再通知 t1线程退出
        Thread.sleep(10 * 1000);
        t.setLoop(false);
    } }
class T extends Thread {
    private int count = 0;
    //    设置一个控制变量
    private boolean loop = true;
    public void setLoop(boolean loop) {
        this.loop = loop;
    }
    @Override
    public void run() {
        while (loop) {
            System.out.println("我是" + (++count) + "线程名=" + Thread.currentThread().getName());
//        让线程休眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10) {
                break;
            } } } }
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

2.3 实现原理

（1） start()方法源码：
① public synchronized void start() {
start0();
}
② start0() 是本地方法，是JVM调用，底层是c/c++实现
真正实现多线程效果的是start0()，而不是 run
private native void start0();
*/
（2）

3.线程常用方法

3.1 setName：设置线程名称，使之与参数name相同

3.2 getName：返回该线程的名称

3.3 start：使该线程开始执行；Java虚拟机底层调用该线程的start0 方法

3.4 run：调用线程对象的run方法

3.5 setPriority：更改线程的优先级

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

3.6 getPriority： 获取线程的优先级

3.7 sleep：在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)

(1)调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）
(2)其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException

(3) 睡眠结束后的线程未必会立刻得到执行(睡眠结束以后CPU可能正在执行其他的线程)
(4) 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性(有时间的单位)
例如：TimeUnit.SECONDS.sleep(1000);

3.8 interrupt

（1）打断sleep，wait，join这些处于阻塞的线程，并且会清空打断状态

private static void test1() throws InterruptedException {
Thread t1 = new Thread(()->{
	sleep(1);
	}, "t1");
	t1.start();
	sleep(0.5);
	t1.interrupt();
	log.debug(" 打断状态: {}", t1.isInterrupted());//false
}
1
2
3
4
5
6
7
8
9

（2）打断正常运行的线程
被打断的线程只是知道有其他线程想要打断自己,但是被打断的线程是由自己决定继续运行还是停止运行。
打断正常运行的线程, 不会清空打断状态。我们可以根据打断状态来判断是继续运行还是停止运行。

public class DemoInterrupt {
    public static void main(String[] args) throws InterruptedException {
//只是知道有其他线程想要打断我,但是被打断的线程是由自己决定继续运行还是停止运行
        Thread t1 = new Thread(() -> {
            while (true) {
                boolean interrupted = Thread.currentThread().isInterrupted();
                if (interrupted) {
                    System.out.println("有人要打断你");
                    break;
                } } });
        t1.start();
        Thread.sleep(1000);
        t1.interrupt();
    } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3.9 yield

(1)线程的礼让。让出CPU，让其他线程执行，但礼让的时间不确定，所以也不一定礼让成功。具体的实现
依赖于操作系统的任务调度器
(2)调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，然后调度执行其它线程

3.10 join

线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务

3.11 getState:获取线程的状态

4.用户线程和守护线程

（1）用户线程：也叫工作线程，当线程的任务执行完或通知方式结束
（2）守护线程：一般是为工作线程服务的，当所有用户线程结束，守护线程自动结束
常见的守护线程：垃圾回收机制
（3）把线程设置为守护线程例子

public class ThreadMethod3 {
    public static void main(String[] args) throws InterruptedException {
        T3 t3 = new T3();
//        如果我们希望当main线程结束后，子线程自动结束
//        只需将子线程设为守护线程即可
        t3.setDaemon(true);
        t3.start();
        for (int i = 0; i < 10; i++) {//主线程
            System.out.println("别卷了..."+i);
            Thread.sleep(1000);
        } } }
class T3 extends Thread{
    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(1000);//休息1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("在学Java...");
        } } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

5.线程的生命周期

Java中用Thread.State枚举表示了线程的几种状态。
public static enum Thread.State extends Enum线程状态。线程可以处于下列状态之一：
（1）NEW
至今尚未启动的线程。
（2）RUNNABLE
正在 Java 虚拟机中执行的线程
（3）BLOCKED
受阻塞并等待获得同步代码块的锁的线程
（4）WAITING
无限期地等待另一个线程来执行某一特定操作
（5）TIMED_WAITING
等待另一个线程来执行操作，取决于指定的等待时间
（6）TERMINATED
已退出的线程。
注意：RUNNABLE 是否真的运行取决于调度器，由操作系统内核来决定，可以细分为Ready就绪和Running运行

6.线程安全

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
我们通过一个案例，演示线程的安全问题：
电影院要卖票，我们模拟电影院的卖票过程。假设要播放的电影是 “葫芦娃大战奥特曼”，本次电影的座位共100个(本场电影只能卖100张票)。
我们来模拟电影院的售票窗口，实现多个窗口同时卖 “葫芦娃大战奥特曼”这场电影票(多个窗口一起卖这100张票)
需要窗口，采用线程对象来模拟；需要票，Runnable接口子类来模拟
模拟票：

public class Ticket implements Runnable {
private int ticket = 100;
/*
* 执行卖票操作
*/
@Override
public void run() {
//每个窗口卖票的操作
//窗口 永远开启
while (true) {
if (ticket > 0) {//有票 可以卖
//出票操作
//使用sleep模拟一下出票时间
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto‐generated catch block
e.printStackTrace();
} /
/获取当前线程对象的名字
String name = Thread.currentThread().getName();
System.out.println(name + "正在卖:" + ticket‐‐);
}}}}
//测试类：
public class Demo {
public static void main(String[] args) {
//创建线程任务对象
Ticket ticket = new Ticket();
//创建三个窗口对象
Thread t1 = new Thread(ticket, "窗口1");
Thread t2 = new Thread(ticket, "窗口2");
Thread t3 = new Thread(ticket, "窗口3");
//同时卖票
t1.start();
t2.start();
t3.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
28
29
30
31
32
33
34
35
36
37

7.线程同步机制

（1）在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何时刻，最多有一个线程访问，以保证数据的完整性。
（2）也可以这样理解：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作。

7.1 同步具体方法-Synchronized

（1）同步代码块
synchronized(对象) { //得到对象的锁，才能操作同步代码
// 需要被同步的代码；
}
（2）synchronized还可以放在方法声明中，表示整个方法为同步方法
public synchronized void m(String name) {
// 需要被同步的代码
}

7.2 Lock锁

（1）从JDK5.0 开始，Java提供了更强大的线程同步机制——通过显示定义同步锁对象来实现同步；同步锁使用Lock对象充当
（2）java.util.concurrent.locks.Lock接口是控制多个线程对资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
（3）ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显示加锁、释放锁

// 获取锁
reentrantLock.lock();
try {
	// 临界区
} finally {
	// 释放锁
	reentrantLock.unlock();
}
1
2
3
4
5
6
7
8

public class TestLock {
    public static void main(String[] args) {
        DemoLock demoLock = new DemoLock();
        new Thread(demoLock).start();
        new Thread(demoLock).start();
        new Thread(demoLock).start();
 } }
class DemoLock implements Runnable {
    int tickNums = 10;
    //定义lock锁
    private final ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            lock.lock();//加锁(位置放在try块里面和外面效果都一样)
            try {
                if (tickNums > 0) {
                    System.out.println(tickNums--);
                } else {
                    break;
                }
            } finally {
                lock.unlock();//解锁
            }  } } }

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

7.3 Lock与synchronized对比

（1）Lock是显示锁(手动开启和关闭锁)，synchronized是隐式锁，出了作用域自动释放
（2）Lock只有代码块锁，synchronized有代码块锁和方法锁
（3）使用Lock锁，JVM将花费较短时间来调度线程，性能更好。并且具有更好的扩展性(提供了更多的子类)
（4）ReentrantLock可中断,可以设置超时时间,可以设置为公平锁,支持多个条件变量;与 synchronized 一样，
都支持可重入
①可重入是指同一个线程如果首次获得了这把锁，那么因为它是这把锁的拥有者，因此有权利再次获取这把锁;
如果是不可重入锁，那么第二次获得锁时，自己也会被锁挡住

static ReentrantLock lock = new ReentrantLock();
public static void main(String[] args) {
	method1();
}
public static void method1() {
	lock.lock();
	try {
		log.debug("execute method1");
		method2();
} finally {
	lock.unlock();
   } }
//第二次调用和第三次调用就相当于重入
public static void method2() {
	lock.lock();
	try {
		log.debug("execute method2");
		method3();
	} finally {
		lock.unlock();
} }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

②可打断，等待锁的过程中，其他线程可以使用interrupt方法终止我的等待
(获取锁方式为lock.lockInterruptibly())

public class Test1 {
    private static ReentrantLock lock = new ReentrantLock();
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            try {
//  如果没有竞争那么此方法就会获取lock对象锁
//  如果有竞争就会进入阻塞队列，可以被其他线程使用 interrupt方法打断
                System.out.println("尝试获取锁");
                lock.lockInterruptibly();
            } catch (InterruptedException e) {
                e.printStackTrace();
                System.out.println("没有获得锁,返回");
                return;
            }
            try {
                System.out.println("获取到锁");
            } finally {
                lock.unlock();
            }});
        lock.lock();//主线程获取锁
        t1.start();//t1线程
        t1.interrupt();//打断t1
    } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

③锁超时(获取锁的方式为lock.tryLock())
还可以设置超时时间-lock.tryLock(1, TimeUnit.SECONDS)

ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(() -> {
	log.debug("启动...");
	if (!lock.tryLock()) {
		log.debug("获取锁失败，返回");
		return;
}
	try {
		log.debug("获得了锁");
	} finally {
		lock.unlock();
} }, "t1");
	lock.lock();//主线程获取锁
	log.debug("获得了锁");
	t1.start();
	try {
		sleep(2);
	} finally {
		lock.unlock();
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

④ReentrantLock 默认是不公平的(公平锁一般没有必要，会降低并发度)
ReentrantLock lock = new ReentrantLock(false);//改为公平锁
不公平锁：当一个线程池有锁，其他线程就会进入阻塞队列去等待，当锁的持有者释放锁时，这些线程就会一涌而上，谁先抢到谁就先获得锁，而不会按照进入阻塞队列的顺序
l

8.互斥锁(就是上面的对象锁)

（1）在Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性
（2）每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问
（3）关键字synchronized 用来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问。
（4）同步的局限性：导致程序的执行效率要降低
（5）同步方法(非静态的)的锁可以是this，也可以是其他对象(要求是同一个对象)
（6）同步方法(静态的)的锁为当前类本身
注意事项：
①同步方法如果没有使用static修饰，默认锁对象为this
②如果方法使用static修饰，默认锁对象：当前类.class
例子：

//1.同步方法没有使用static修饰
public class SellTicket02 {
    public static void main(String[] args) {
        T2 t2 = new T2();
        new Thread(t2).start();//第一个线程窗口
        new Thread(t2).start();//第二个线程窗口
        new Thread(t2).start();//第三个线程窗口
    } }
class T2 implements Runnable {
    private int ticketNum = 100;//让多个线程共享 ticketNum
    private boolean loop = true;
    Object object = new Object();
    public void sell() {
        synchronized (/*this*/object) {
            if (ticketNum <= 0) {
                System.out.println("售票结束。。。");
                loop = false;
                return;
            }
//            休眠50秒
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口" + Thread.currentThread().getName() + "售出一张票"
                    + "剩余票数=" + (--ticketNum));
        } }
    @Override
    public void run() {
        while (loop) {
            sell();
        } } }
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

// 2.同步方法为静态方法
public class SellTicket05 {
    public static void main(String[] args) {
        T2 t2 = new T2();
        new Thread(t2).start();//第一个线程窗口
        new Thread(t2).start();//第二个线程窗口
        new Thread(t2).start();//第三个线程窗口
    } }
class T5 implements Runnable {
    private static int ticketNum = 100;//让多个线程共享 ticketNum
    private static boolean loop = true;
    public static void sell() {
        synchronized (T5.class) {
            if ( ticketNum<= 0) {
                System.out.println("售票结束。。。");
                loop = false;
                return;
            }
//            休眠50秒
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口" + Thread.currentThread().getName() + "售出一张票"
                    + "剩余票数=" + (--ticketNum));
        } }
    @Override
    public void run() {
        while (loop) {
            sell();
        } } }
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

9.线程死锁

多个线程都占用了对方的锁资源，但不肯想让，导致了死锁，在编程时一定要避免死锁的发生

public class DeadLock {
    public static void main(String[] args) {
        DemoDeadLock A = new DemoDeadLock(true);
        DemoDeadLock B = new DemoDeadLock(false);
        A.start();
        B.start();
    } }
class DemoDeadLock extends Thread {
    static Object o1 = new Object();
    static Object o2 = new Object();
    boolean flag;
    public DemoDeadLock(boolean flag) {
        this.flag = flag;
    }
    @Override
    public void run() {
//业务逻辑分析:
// 1.如果flag 为T,线程A 就会先得到 o1 对象锁，然后尝试去获取 o2 对象锁
// 2.如果线程A 得不到 o2 对象锁，就会Blocked
// 3.如果flag 为F,线程B 就会先得到 o2 对象锁，然后尝试去获取 o1 对象锁
// 4.如果线程B 得不到 o1 对象锁，就会Blocked
        if (flag) {
            synchronized (o1) {//对象互斥锁，下面就是同步代码
                System.out.println(Thread.currentThread().getName() + "进入1");
                synchronized (o2) {
                    System.out.println(Thread.currentThread().getName() + "进入2");
                } }
        } else {
            synchronized (o2) {//对象互斥锁，下面就是同步代码
                System.out.println(Thread.currentThread().getName() + "进入2");
                synchronized (o1) {
                    System.out.println(Thread.currentThread().getName() + "进入1");
                } } } } }
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

10.释放锁

（1）当前线程的同步方法、同步代码块执行结束
（2）当前线程在同步代码块、同步方法中遇到break、return
（3）当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束
（4）当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁
下面操作不会释放锁：
①线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁
②线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁
提示：应尽量避免使用suspend()和resume()来控制线程，该方法不再推荐使用