线程的基本概念
# 1. 进程、线程和多线程的概念
进程是程序的一次动态执行过程,它经历了从代码加载、执行到执行完毕的一个完整过程,这个过程也是进程本身从产生、发展到最终消亡的过程。多进程操作系统能同时运行多个进程(程序),由于 CPU 具备分时机制,所以每个进程都能循环获得自己的 CPU 时间片。由于 CPU 执行速度非常快,使得所有程序好象是在“同时”运行一样。 线程是比进程更小的执行单位,线程是进程内部单一的一个顺序控制流。也被称为轻量级进程,同一个进程中的所有线程都将共享进程的内存地址空间。因此这些线程都能访问相同的变量并在同一个堆上分配对象。当多个线程访问某个状态变量并且其中一个线程执行写入操作时,必须采用同步机制来协同这些线程对变量的访问。 Java中主要的同步机制是synchronized关键字,它提供了一种独占加锁的方式。但“同步”这个术语还包括volatile类型的变量,显示锁(Explicit Lock)以及原子变量。 所谓 多线程 是指一个进程在执行过程中可以产生多个线程,这些线程可以同时存在、同时运行,形成多条执行线索。一个进程可能包含了多个同时执行的线程。 多线程是实现并发机制的一种有效手段。进程和线程一样,都是实现并发的一个基本单位。线程和进程的主要差别体现在以下两个方面: ( 1)、同样作为基本的执行单元,线程是划分得比进程更小的执行单位。 ( 2)、每个进程都有一段专用的内存区域。与此相反,线程却共享内存单元(包括代码和数据),通过共享的内存单元来实现数据交换、实时通信与必要的同步操作。
# 1.1 多线程和多进程的区别?
最本质的区别就是,每个进程用于一整套的变量,而线程则是共享数据。而且,与进程相比较,线程更“轻量级”,创建、撤销一个线程比启动一个新进程的开销要小很多。
# 1.2 并发编程的三个特性:原子性,可见性,有序性
在并发编程中,我们通常会遇到以下三个问题:原子性问题,可见性问题,有序性问题。我们先看具体看一下这三个概念:
# 1.2.1 原子性
即一个操作或者多个操作
要么全部执行并且执行的过程不会被任何因素打断,要么就都不执行。 假定有两个操作A和B,如果从执行A的线程来看,当另一个线程执行B时,要么将B全部执行完,要么完全不执行B。那么A和B对彼此来说是原子的。 原子操作是指:对于访问同一个状态的所有操作(包括该操作本身)来说,这个操作是一个以原子方式执行的操作。 例如一个经典的银行转账问题: 比如从账户A向账户B转1000元,那么必然包括2个操作:从账户A减去1000元,往账户B加上1000元。 试想一下,如果这2个操作不具备原子性,会造成什么样的后果。假如从账户A减去1000元之后,操作突然中止。然后又从B取出了500元,取出500元之后,再执行 往账户B加上1000元 的操作。这样就会导致账户A虽然减去了1000元,但是账户B没有收到这个转过来的1000元。 所以这2个操作必须要具备原子性才能保证不出现一些意外的问题。
# 1.2.2 可见性
是指当多个线程访问同一个变量时,一个线程修改了这个变量的值,其他线程能够立即看得到修改的值
举个简单的例子,例如下面这段代码: 假若执行线程1的是CPU1,执行线程2的是CPU2。由上面的分析可知,当线程1执行 i =10这句时,会先把i的初始值加载到CPU1的高速缓存中,然后赋值为10,那么在CPU1的高速缓存当中i的值变为10了,却没有立即写入到主存当中。 此时线程2执行 j = i,它会先去主存读取i的值并加载到CPU2的缓存当中,注意此时内存当中i的值还是0,那么就会使得j的值为0,而不是10.这就是可见性问题,线程1对变量i修改了之后,线程2没有立即看到线程1修改的值。
//线程1执行的代码
int i = 0;
i = 10;
//线程2执行的代码
j = i;
2
3
4
5
# 1.2.3 有序性
即程序执行的顺序按照代码的先后顺序执行 比如下面这段代码 代码中定义了一个int型变量,定义了一个boolean类型变量,然后分别对两个变量进行赋值操作。从代码顺序上看,语句1是在语句2前面的,那么JVM在真正执行这段代码的时候会保证语句1一定会在语句2前面执行吗?不一定,为什么呢?这里可能会发生指令重排序(Instruction Reorder)
int i = 0;
boolean flag = false;
i = 1; //语句1
flag = true; //语句2
2
3
4
# 2. 线程的基本实例
# 2.1 未使用多线程的情况
public class Test {
public static void main(String[] args) {
new TestThraed().run();
for (int i = 0; i < 10; i++) {
System.out.println("main方法在运行"+i);
}
}
}
class TestThraed {
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("TestThread在运行"+i);
}
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
上面这段代码是没有使用多线程的情况,程序输出结果是按顺序执行的,也就是先调用TestThread中的run方法,然后再执行main中的for循环
TestThread在运行0
TestThread在运行1
........省略部分..........
TestThread在运行9
main方法在运行0
main方法在运行1
........省略部分..........
main方法在运行9
2
3
4
5
6
7
8
# 2.2 使用多线程的情况
public class Test {
public static void main(String[] args) {
/**
* 开启一个新线程并启动它【不要直接调用run方法】
* 如果直接调用Thread.run()方法,只会执行同一线程【main线程】的任务,而不会启动新线程。
*/
new TestThraed().start();
for (int i = 0; i < 10; i++) {
System.out.println("main方法在运行"+i);
}
}
}
class TestThraed extends Thread{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("TestThread在运行"+i);
}
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
使用了多线程后,程序的结果是交叉执行的。也就是在main线程中开辟了一个新的线程。由于main本身也占用一条线程,实际上在命令行中运行 java 命令时,就启动了一个 JVM 的进程,默认情况下此进程会产生两个线程:一个是 main()方法线程,另外一个就是垃圾回收( GC)线程。所以这里是两条线程main线程和new TestThread().start()线程。两个线程同时交替运行着。 结果如下:
main方法在运行0
TestThread在运行0
main方法在运行1
TestThread在运行1
........省略部分..........
main方法在运行8
main方法在运行9
TestThread在运行8
TestThread在运行9
2
3
4
5
6
7
8
9
# 3. 创建线程的两种方式
要想使某个程序是多线程运行的,可以将其变为多线程的程序。多线程程序的run方法中才是该多线程需要执行分解任务的逻辑。任意一个类都是可以变成多线程程序的。 创建线程的方式有如下两种:
- 实现Runnable接口,该接口中只有一个抽象的run方法 public abstract void run();
- 继承Thread类,其实Thread类内部也是实现了Runnable接口。只不过内部封装了对线程的一些常用操作。
# 3.1 实现Runnable接口的方式创建线程
实现Runnable接口,重写run方法
//实现Runnable接口的方式来创建线程
public class Programmer implements Runnable{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("第"+i+"次");
}
}
}
//测试多线程
public class TestProgrammer {
public static void main(String[] args) {
//1.创建真实角色
Programmer pro = new Programmer();
//2.创建代理角色+真实角色的引用
Thread proxy = new Thread(pro);
//3.调用start方法,启动线程
proxy.start();
for (int i = 0; i < 100; i++) {
System.out.println("QQ");
}
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 3.2 继承Thread类方式来创建线程
继承Thread类,重写run方法
//继承Thread类的方式来创建线程
public class Rabbit extends Thread {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("兔子跑了"+i+"步");
}
}
}
//测试多线程
public class TestThread {
public static void main(String[] args) {
Rabbit rabbit = new Rabbit();
rabbit.start();//不要调用run方法
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
注意:启动线程时,不要直接调用Thread或者Runnable接口的run方法,直接调用run方法只会执行同一个线程中的任务。而不会启动新线程。 应该调用Thread.start()方法。这个方法将创建一个执行run方法的新线程。
# 4. 总结
# 4.1 线程和进程的区别?
进程是一个程序的动态执行过程,它会在CPU给分配的一块内存中执行一段程序【一个人在一个房间里执行一个程序】 线程只是比进程更小的执行单位,它是进程内部单一的一个顺序控制流。 多线程则是把一个任务进行分解,一个程序在内存执行的时候产生多个线程,多线程共享某块数据。让多个线程来执行该一个程序【多个人在一个房间执行一个程序】 一个进程中可能包括多个线程,一个线程只能属于一个进程。
# 4.2 线程的创建方式?
继承Thread类或者实现Runnable接口
# 4.3 继承Thread类还是实现Runnable接口?
推荐实现Runnable接口,避免单继承问题
# 4.4 线程的启动?
启动一个线程需要调用start()方法,不要直接调用run方法。run方法只会执行同一个线程中的任务而不会去开启新线程。start方法是创建一个执行run方法的新线程。