一、并发与并行
- 并发：指两个或多个事件在同一时间段内发生。
- 并行：指两个或多个事件在同一时刻发生（同时发生）。
Notice：
单核处理器的计算机肯定是不能并行的处理多个任务的，只能是多个任务在单个CPU上并发运行。同理，线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个线程一个线程的去运行，但、当系统只有一个CPU时，线程会以某种顺序执行多个线程，我们把这种情况称之为线程调度。
二、线程与进程
- 进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
- 线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
简而言之，一个程序运行后至少有一个线程，一个进程中可以包含多个线程。
多线程的好处：
- 效率高
- 多个线程之间互不影响
线程调度：
- 分时调度：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间；
- 抢占式调度：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个（线程随机性），Java使用的为抢占式调度。
三、Thread类中有关线程的方法
构造方法：
- public Thread()：分配一个新的线程对象。
- public Thread(String name)：分配新的 Thread 对象。
- public Thread(Runnable target):分配一个带有指定目标新的线程对象。
- public Thread(Runnable target，String name):分配一个带有指定目标的线程对象并指定名字。
常用方法：
-
public String getName():获取当前线程名称。
-
public void start():导致此线程开始执行；Java虚拟机调用此线程的run方法。
-
public void run():此线程要执行的任务在此处定义代码。
-
public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停，毫秒数结束之后，线程继续执行。
-
public static Thread currentThread():返回对当前正在执行的线程对象的引用。
四、创建线程类
Java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或是其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段程序执行的代码，Java使用线程执行体来表示这段程序流。
单线程程序：java程序中只有一个线程，执行从main方法开始，从上到下依次执行。
主线程：执行主(main)方法的线程。
JVM执行main方法，main方法会进入到栈内存，JVM会找操作系统开辟一条main方法通向CPU的执行路径，CPU就可以通过这个路径来执行main方法，而这个路径有一个名字，叫主线程。
1.创建线程的第一种方式：创建Tread类的子类。
Java中通过继承Thread类来创建并启动多线程的步骤如下：
- 定义Tread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程需要完成的任务，因此把run方法称为线程执行体；
- 创建Thread子类的实例，即创建了线程对象；
- 调用线程对象的start方法来启动线程，执行run方法。
void start()使该线程开始执行；Java虚拟机调用该线程的run方法。
结果是两个线程并发的运行；当前线程(main线程)和另一个线程(创建的新线程，执行其run方法)。
多次启动一个线程使非法的。特别是当线程已经结束后，不能再重新启动。
获取线程的名称：
- 使用Thread类种的方法getName()
String getName()返回该线程的名称； - 可以先获取当前正在执行的线程，使用线程中的方法getName()获取线程名称
start Thread currentThread()返回对当前正在执行的线程对象的引用。
设置线程名称：
- 使用Thread类中的方法setName(名字)
void setName(String name) 改变线程名称，使之与参数name相同。 - 创建一个带参数的构造方法，参数传递线程的名称；调用父类的带参构造方法，将线程名称传递给父类，让父类(Thread)给线程起名
Thread(String name)：分配新的 Thread 对象。
2.创建线程的第一种方式：实现Runnable接口
java.lang.Runnable接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。
实现步骤：
1.创建一个Runnable接口的实现类；
2.在实现类中重写Runnable接口的run方法，设置线程任务；
3.创建一个Runnable接口的实现类对象；
4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象；
5.调用Thread类中的start方法，开启的新线程执行run方法。
public class RunnableImpl implements java.lang.Runnable {
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}
public class Demo06Runnable {
public static void main(String[] args) {
RunnableImpl run = new RunnableImpl();
Thread t = new Thread(run);
t.start();
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}
实现Runnable接口比继承Thread类所具有的优势：
- 适合多个相同的程序代码的线程去共享同一个资源。
- 可以避免Java中的单继承的局限性。
- 增加了程序的健壮性，实现解耦操作（实现Runnable接口的方式，把设置线程任务和开启新线程进行分离），代码可以被多个线程共享，代码和线程独立。
实现类中，重写了run方法，用来设置线程任务。
创建Thread类对象，调用start方法：用来开启新线程。 - 线程池只能放入实现Runnable或Callable类线程，不能直接放入继承Thread的类。
扩充：在Java中，每次程序运行至少启动两个线程，一个使main线程，一个是垃圾收集线程。因为每当使用Java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实就是操作系统中启动一个进程。
五、匿名内部类的方式实现线程的创建
1.匿名内部类的作用：简化代码。
把子类继承父类、重写父类的方法、创建子类对象合一步完成
把实现类实现接口、重写接口中的方法、创建实现类对象合一步完成
2.匿名内部类的最终产物：子类/实现类对象，这个类没有名字
3.使用格式：
new 父类/接口() {
重写父类/接口中的方法;
};
eg:
public class Demo07InnerClassThread {
public static void main(String[] args) {
new Thread() {
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}.start();
//线程的接口Runnable
Runnable r = new Runnable() {
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
};
new Thread(r).start();
//简化接口的方式
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}).start();
}
}六、线程同步
当我们使用多线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。要解决多线程并发访问一个资源的安全性问题，Java中提供了同步机制（synchronized）来解决。
也就是说在某个线程修改共享资源时，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU资源，完成对应操作，保证了数据的同步性，解决了线程不安全的现象。
为了保证每个线程都能正常执行原子操作，Java引入了线程同步机制。
完成同步机制的三种方式：
1.同步代码块
同步代码块：synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。格式:
synchronized(锁对象) {
可能出现线程安全问题的代码(访问了共享数据的代码)
}同步锁（对象锁）：对象的同步锁只是一个概念，可以想象为在对象上标记了一个锁。
- 锁对象可以是任意类型
- 保证多个线程使用的对象是同一个
Notice：
在任何时候，最多允许一个线程拥有同步锁，谁拿到锁就进入代码块，其他的线程只能在外面等着（BLOCKED）。
同步保证了只能有一个线程在同步中执行共享数据，保证了安全，但程序频繁的判断锁、获取锁、释放锁，程序的效率会降低。
2.同步方法
同步方法：使用synchronized修饰的方法，就叫做同步方法，保证A线程执行该方法的时候，其他线程只能在方法外等着。
使用步骤：
1.把访问了共享数据的代码抽取出来，放到一个方法中
2.在方法上添加synchronized修饰符
格式：
修饰符 synchronized 返回值类型 方法名(参数列表) {
可能出现线程安全问题的代码(访问了共享数据的代码)
}同步方法也会把方法内部的代码锁住，只让一个线程执行。同步方法的锁对象就是实现类对象，也就是this。
同步锁是谁？
对于非static方法，同步锁就是this；
对于static方法，我们使用当前方法所在类的字节码对象（类名.class）。
3.锁机制
java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更为广泛的锁定操作，同步代码块/同步方法具有的功能Lock都有，除此之外更强大，更体现面向对象。
Lock锁也称同步锁，加锁与释放锁方法化了，如下：
- public void lock():加同步锁。
- public void unlock():释放同步锁。
七、线程状态
当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态，在线程的生命周期中，有以下六种状态：
| 线程状态 | 导致状态发生的条件 |
|---|---|
| NEW（新建） | 线程刚被创建，但是并未启动。还没调用start方法。 |
| Runnable（可运行） | 线程可以在Java虚拟机中云运行的状态，可能正在运行自己的代码，也可能没有，这取决于操作系统处理器。 |
| Blocked（锁阻塞） | 当一个线程试图获取一个锁对象，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。 |
| Waiting（无限等待） | 一个线程等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后不是自动能唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。 |
| Timed Waiting（计时等待） | 同Waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Tread.sleep、Object.wait。 |
| Teminated（被终止） | 因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。 |
这几种状态的关系如下图：
阻塞状态：具有CPU的执行资格，等待CPU空闲时执行；
休眠状态：放弃COU的执行资格，CPU空闲，也不执行。
下面我们来研究一下线程从Runnable状态与非运行状态之间的转换问题。
1.Timed Waiting（计时等待）
Timed Waiting在API中的描述为：等待另一个线程来执行取决于指定等待时间的操作的线程处于这种状态。光看这句话，真的是一脸懵逼，我们通过一个案例来理解这一状态叭。
进入到TimedWaiting有两种方式：
- 使用sleep(long m)方法，在毫秒值结束之后，线程睡醒进入到Runnable/Blocked状态；
- 使用wait(long m)方法，wait方法如果在毫秒值结束之后，还没有被notify唤醒，就会自动醒来。
唤醒的方法：
- void notify():唤醒在此对象监视器上等待的单个线程。随即唤醒一个。
- void notifyAll():唤醒在此对象监视器上等待的所有线程。
/*
实现一个计算器，计数到100，在每个数字之间暂停一秒，每隔10个数字输出一个字符串。
*/
public class CounterThread extends Thread{
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 10 == 0) {
System.out.println("---------" + i);
}
System.out.println(i);
try {
//使用sleep方法让程序睡眠一秒
Thread.sleep(1000);
System.out.println(" 线程睡眠1秒");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
new CounterThread().start();
}
}
public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停，毫秒数结束之后，线程继续执行。
在run方法中添加sleep语句，这样就强制当前正在执行的线程休眠（暂停执行），以“减慢线程”。
其实当我们调用了sleep方法后，当前执行的线程就进入到“休眠状态”，其实就是所谓的Timed Waiting（计时等待）。
Remember：
- 进入TIME_WAITING状态的一种常见情形时调用sleep方法，单独的线程也可以调用，不一定非要有协作关系。
- 为了让其他线程有机会执行，可以将Thread.sleep()的调用放在线程之内，这样才能保证该线程执行过程中会睡眠。
- sleep与锁无关，线程睡眠到期自动苏醒，并返回Runnable（可运行）状态。
Tip：
sleep()中指定的时间是线程不会运行的最短时间。因此，sleep()方法不能保证该线程到期后就开始立刻执行。
Timed Waiting线程状态图：
2.BLOCKED（锁阻塞）
BLOCKED在API中的描述为：受阻塞并等待某个监视器锁的线程处于这种状态。 比如：线程A与线程B代码中使用同一锁，如果线程A获取到锁，线程A进入到Runnable状态，那么线程B就进入到Blocked锁阻塞状态。除此之外Waiting以及Timed Waiting状态也会在某种情况下进入阻塞状态。
Blocked的线程状态图：
3.Waiting（无限等待）
Waiting状态在API中的描述为：无限期地等待另一个线程来执行某一特定操作的线程处于这种状态。
我们通过一个代码来学习一下：
/*
等待唤醒案例：线程之间的通信
创建一个顾客线程（消费者）：告知老板要的包子的种类和数量，调用wait方法，放弃CPU的执行，进入到WAITING状态
创建一个老板线程（生产者）：花了5秒做包子，做好包子后，调用notify，唤醒顾客吃包子
Notice：
顾客和老板线程必须使用同步代码块包裹起来，保证等待和唤醒只能有一个在执行
同步使用的锁对象必须保证唯一
只有锁对象才能调用wait和notify方法
Object类中的方法：
void wait()：在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。
void notify()：唤醒在此对象监视器上等待的单个线程。会继续执行wait方法之后的代码
*/
public class DemoWaitNotify {
public static void main(String[] args) {
//创建锁对象，保证唯一
Object obj = new Object();
//创建一个顾客线程,使用匿名内部类
new Thread() {
@Override
public void run() {
//一直等着买包子
while (true) {
//保证等待和唤醒只能有一个在执行,需要使用同步技术
synchronized (obj) {
System.out.println("告知老板要的包子的种类和数量");
//调用wait方法，放弃CPU的执行，进入到WAITING状态
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
//唤醒之后执行的代码
System.out.println("包子已经做好了，我要开动了！");
System.out.println("==========================");
}
}
}
}.start();
//创建一个老板线程
new Thread() {
@Override
public void run() {
//一直做包子
while (true) {
try {
sleep(5000);//花五秒做包子
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (obj) {
System.out.println("老板5秒钟之后做好包子，告知顾客可以吃了");
//做好包子后，调用notify，唤醒顾客吃包子
obj.notify();
}
}
}
}.start();
}
}
八、等待唤醒机制
1.线程间的通信
概念：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不同。
比如：线程A用来生产包子，线程B用来吃包子，包子可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，那么线程A与线程B之间就存在线程通信问题。
为什么要处理线程间通信：
多个线程并发执行时，在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行，那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。
如何保证线程间通信有效利用资源：
多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。就是多个线程在操作同一份数据时，避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段即——等待线程唤醒。
2.等待线程唤醒机制
什么是等待线程唤醒机制
这是多个线程间的一种协作机制。谈到线程我们经常想到的使线程间的竞争（race），比如去争夺锁，但这并不是故事的全部，线程间也会有协作机制。就像人和人之间既有竞争又有合作。
就是在一个线程进行了规定操作之后，就进入等待状态（wait（）），等待其他线程执行完他们的指定代码过后，再将其唤醒（notify（））；在有多个线程等待时，如果需要，可以使用notifyAll（）来唤醒所有的等待线程。
wait/notify就是线程间的一种协作机制。
等待唤醒中的方法：
等待唤醒机制就是用于解决线程间通信问题的，使用到的3个方法含义如下：
- wait：线程不再活动，不再参与调度，进入wait set中，因此不会浪费CPU资源，也不会去竞争锁了，这时的线程状态即是WAITING。它还要等着别的线程执行一个特别的动作，也就是“通知（notify）”在这个对象上等待的线程从wait set中释放出来，重新进入到调度队列（ready queue）中
- notify：则选取所通知对象的wait set中的一个线程释放；例如，餐馆有空座位后，等候就餐最久的顾客最先入座。
- notifyAll：则释放所通知对象的wait set上的全部线程。
Notice：
哪怕只通知一个等待的线程，被告知线程也不能立即恢复执行，因为它中断的地方是在同步块内，而此刻它已经不持有锁，所以它需要再次尝试去获取锁（很可能面临其他线程的竞争），成功后才能在当初调用wait方法之后的地方恢复执行。
总结：
1.如果能获取锁，线程就从WAITING状态变成RUNNABLE状态；
2.否则，从wait set出来，又进入entry set，线程就从WAITING状态又变成BLOCKED状态。
调用wait和notify方法需要注意的细节：
- wait 方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
- wait方法与notify方法是属于Object类的方法。因为：锁对象可以是任意对象，而任意对象的所属类都继承了Object类的。
- wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这两个方法。
扫一扫
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
