关于多线程、线程池、线程安全问题
多线程
1、基础概念
1.1 多线程技术
- 从软件或者硬件上实现同时执行多个任务
- 具有多线程能拦的计算机因有硬件支持而能够在同一时间执行多个线程
- 多线程编程常常也将其称之为并发编程
1.2 并发和并行
- 并行
- 在同一时刻，有多个指令在多个CPU上同时进行
- 并发
- 在同一时刻，有多个指令在单个CPU上交替进行
1.3 进程和线程
- 进程：是正在运行的软件，且一个进程最少包括一个线程
- 独立性：进程是一个可以独立运行的基本单位，也是操作系统调度的最小单元，同时也是系统分配资源和调度的独立单位
- 动态性：进程的实质是程序的一次执行过程，进程是动态产生，动态消亡的
- 并发性：任何进程都可以同其他进程一起并发执行
- 线程：是进程中的单个顺序控制流，是一条执行路径
- 单线程：一个进程如果只有一条执行路径，则称为单线程程序
- 多线程：一个程序如果有多条执行路径，则称为多线程程序
- 二者关系
- 线程是进程中的单个顺序控制流，是依赖于进程的，而一个进程最少包括一个线程，进程可以存在很多任务，每一个任务就是一个线程，这些执行路径之间没有任何的关联关系
2、线程的实现
2.1 继承Thread类
- Thread类
- Thread类就是JDK给我们定义的一个线程类
- 方法介绍
| 方法名 | 说明 |
|---|---|
| void run() | 在线程开启后，此方法将被调用执行 |
| void start() | 使此线程开始执行，Java虚拟机会调用run方法() |
- 实现步骤
- 定义一个类继承自Thread类，这里我们定义这个类为MyThread
- 重写Thread类中的run方法（run方法中重写的就是要被线程所执行的代码）
- 创建MyThread类的对象
- 启动线程（调用start方法）
- 注意：多线程的执行，具有随机性
- 代码实现
public class MyThread extends Thread {
@Override
public void run() {
for(int i=0; i<100; i++) {
System.out.println(i);
}
}
}
public class MyThreadDemo {
public static void main(String[] args) {
MyThread my1 = new MyThread();
MyThread my2 = new MyThread();
// my1.run();
// my2.run();
//void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法
my1.start();
my2.start();
}
}
- 两个问题
- 为什么重写run方法
- 因为run方法封装的就是要被线程执行的代码
- run方法和start方法的区别
- run()：封装线程执行的代码，直接调用，相当于普通方法的调用
- start()：启动线程；然后由JVM调用此线程的run()方法
- start方法只能调用一次，如果调用多次程序将报错
- 为什么重写run方法
2.2 实现Runnable接口
- Thread构造方法
| 方法名 | 说明 |
|---|---|
| Thread(Runnable target) | 分配一个新的Thread对象 |
| Thread(Runnable target, String name) | 分配一个新的Thread对象 |
- 实现步骤
- 定义一个类实现Runnable接口，这里我们定义为MyRunnable
- 在MyRunnable类中重写run()方法
- 创建MyRunnable类的对象
- 创建Thread类的对象，把MyRunnable类对象作为构造方法的参数
- 启动线程
- 代码实现
public class MyRunnable implements Runnable {
@Override
public void run() {
for(int i=0; i<100; i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
public class MyRunnableDemo {
public static void main(String[] args) {
//创建MyRunnable类的对象
MyRunnable my = new MyRunnable();
//创建Thread类的对象，把MyRunnable对象作为构造方法的参数
//Thread(Runnable target)
// Thread t1 = new Thread(my);
// Thread t2 = new Thread(my);
//Thread(Runnable target, String name)
Thread t1 = new Thread(my,"坦克");
Thread t2 = new Thread(my,"飞机");
//启动线程
t1.start();
t2.start();
}
}
2.3 实现Callable类
- 方法介绍
| 方法名 | 说明 |
|---|---|
| V call() | 计算结果，如果无法计算结果，则抛出一个异常 |
| FutureTask(Callable callable) | 创建一个 FutureTask，一旦运行就执行给定的 Callable |
| V get() | 如有必要，等待计算完成，然后获取其结果 |
- 实现步骤
- 定义一个类实现Callable接口，这里我们将这个类定义为MyCallable
- 在MyCallable类中重写call（）方法
- 创建MyCallable类的对象
- 创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数
- 创建Thread类的对象，把FutureTask对象作为构造方法的参数
- 启动线程
- 调用get方法，就可以获取线程结束之后的结果
- 代码实现
public class MyCallable implements Callable<String> {
@Override
public String call() throws Exception {
for (int i = 0; i < 100; i++) {
System.out.println("跟女孩表白" + i);
}
//返回值就表示线程运行完毕之后的结果
return "答应";
}
}
public class Demo {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//线程开启之后需要执行里面的call方法
MyCallable mc = new MyCallable();
//Thread t1 = new Thread(mc);
//可以获取线程执行完毕之后的结果.也可以作为参数传递给Thread对象
FutureTask<String> ft = new FutureTask<>(mc);
//创建线程对象
Thread t1 = new Thread(ft);
String s = ft.get();
//开启线程
t1.start();
//String s = ft.get();
System.out.println(s);
}
}
2.4 三种实现方式的区别
- 站在返回值的角度
- 继承Thread类和实现Runnable接口的方式没有返回值，获取不到线程执行的结果
- 实现Callable接口的方式有返回值，所以可以获取线程执行的结果
- 站在继承方式的角度
- 继承Thread类的方式，编程比较简单，可以直接使用Thread类的方法，但同时它的扩展性相对较弱
- 实现Runnable或Callable接口，因为在Java中一个类可以实现多个接口，因此扩展性较高，但同时编程相对复杂，不能直接使用Thread类中的方法
3、Thread类的API
3.1 和线程名称相关
- 方法介绍
| 方法名 | 说明 |
|---|---|
| void setName(String name) | 设置线程名称 |
| public final String getName( ) | 获取线程名称 |
| Thread currentThread() | 返回对当前正在执行的线程对象的引用 |
- 代码实现
public class MyThread extends Thread {
public MyThread() {}
public MyThread(String name) {
super(name);
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName()+":"+i);
}
}
}
public class MyThreadDemo {
public static void main(String[] args) {
MyThread my1 = new MyThread();
MyThread my2 = new MyThread();
//void setName(String name)：将此线程的名称更改为等于参数 name
my1.setName("高铁");
my2.setName("飞机");
//Thread(String name)
MyThread my1 = new MyThread("高铁");
MyThread my2 = new MyThread("飞机");
my1.start();
my2.start();
//static Thread currentThread() 返回对当前正在执行的线程对象的引用
System.out.println(Thread.currentThread().getName());
}
}
3.2 线程休眠
- 相关方法
| 方法名 | 说明 |
|---|---|
| static native void sleep (long millis) | 使当前正在执行的线程停留（暂停执行）指定的毫秒数 |
- 代码实现
public class MyRunnable implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "---" + i);
}
}
}
public class Demo {
public static void main(String[] args) throws InterruptedException {
/*System.out.println("睡觉前");
Thread.sleep(3000);
System.out.println("睡醒了");*/
MyRunnable mr = new MyRunnable();
Thread t1 = new Thread(mr);
Thread t2 = new Thread(mr);
t1.start();
t2.start();
}
}
3.3 线程优先级
3.3.1 线程调度
- 两种调度方式
- 分时调度模型
- 所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片
- 抢占式调度模型
- 优先级高的线程优先使用CPU，如果优先级相同，那么随机选择一个，优先级高的线程获取的CPU时间片相对多一些
- 分时调度模型
- JAVA使用的是抢占式调度模型
- 随机性
- 假如计算机只有一个CPU ，那么某一时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是随机性的，因为谁抢到CPU的使用权是不一定的
3.3.2 相关方法
| 方法名 | 说明 |
|---|---|
| final int getPriority() | 返回此线程的优先级 |
| final void setPriority(int newPriority) | 更改此线程的优先级线程默认优先级是5；线程优先级的范围是：1-10 |
- 代码实现
public class MyCallable implements Callable<String> {
@Override
public String call() throws Exception {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + "---" + i);
}
return "线程执行完毕了";
}
}
public class Demo {
public static void main(String[] args) {
//优先级: 1 - 10 默认值:5
MyCallable mc = new MyCallable();
FutureTask<String> ft = new FutureTask<>(mc);
Thread t1 = new Thread(ft);
t1.setName("飞机");
t1.setPriority(10);
//System.out.println(t1.getPriority());//5
t1.start();
MyCallable mc2 = new MyCallable();
FutureTask<String> ft2 = new FutureTask<>(mc2);
Thread t2 = new Thread(ft2);
t2.setName("坦克");
t2.setPriority(1);
//System.out.println(t2.getPriority());//5
t2.start();
}
}
3.4 守护线程
- Java语言中的线程可以分为普通线程和守护线程
- 守护线程的作用
- 为普通线程服务，如果普通线程结束，守护线程也会结束
- JVM会检查线程的类型，如果当前的JVM进程中所有的线程都是守护线程，Jvm停止运行。
- 相关方法
| 方法名 | 说明 |
|---|---|
| void setDaemon(boolean on) | 将此线程标记为守护线程 |
- 代码实现
public class MyThread1 extends Thread {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(getName() + "---" + i);
}
}
}
public class MyThread2 extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName() + "---" + i);
}
}
}
public class Demo {
public static void main(String[] args) {
MyThread1 t1 = new MyThread1();
MyThread2 t2 = new MyThread2();
t1.setName("女神");
t2.setName("备胎");
//把第二个线程设置为守护线程
//当普通线程执行完之后,那么守护线程也没有继续运行下去的必要了.
t2.setDaemon(true);
t1.start();
t2.start();
}
}
4、线程安全问题
4.1 数据安全问题
- 安全问题出现的条件
- 是多线程环境
- 有共享数据
- 有多条语句操作共享数据
- 如何解决多线程安全问题
- 基本思想
- 让程序没有安全问题的环境
- 如何实现
- 把多条语句操作共享数据的代码锁起来，让任意时刻只能有一个线程执行即可
- 基本思想
- 锁在Java中存在两种
- 内部锁
- 就是通过synchronized进行实现
- 显式锁
- 是Jdk1.5之后提供的Lock对象进行实现
- 内部锁
- 内部锁的实现
- 同步代码块
- 同步方法
- 静态同步方法
- 显式锁
- 创建Lock类的对象
4.2 同步代码块
- 格式
- synchronized(任意对象) { 多条语句操作共享数据的代码 }
- synchronized(任意对象）
- 就相当于给代码加锁，任意对象就能看成是一把锁
- 同步的好处和弊端
- 好处
- 解决了多线程的数据安全问题
- 弊端
- 当线程很多时，因为每个线程都会判断同步上的锁，这会很耗费资源，降低程序运行效率
- 好处
- 代码实现
public class SellTicket implements Runnable {
private int tickets = 100;
private Object obj = new Object();
@Override
public void run() {
while (true) {
synchronized (obj) { // 对可能有安全问题的代码加锁,多个线程必须使用同一把锁
//t1进来后，就会把这段代码给锁起来
if (tickets > 0) {
try {
Thread.sleep(100);
//t1休息100毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
//窗口1正在出售第100张票
System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
tickets--; //tickets = 99;
}
}
//t1出来了，这段代码的锁就被释放了
}
}
}
public class SellTicketDemo {
public static void main(String[] args) {
SellTicket st = new SellTicket();
Thread t1 = new Thread(st, "窗口1");
Thread t2 = new Thread(st, "窗口2");
Thread t3 = new Thread(st, "窗口3");
t1.start();
t2.start();
t3.start();
}
}
- 注意
- 多个线程一定要使用同一把锁
4.3 同步方法
- 同步方法
- 就是把synchronized关键字加到方法上
- 格式
- 修饰符 synchronized 返回值类型 方法名(方法参数) { 方法体；}
- 同步方法的锁对象
- 就是this
- 同步静态方法
- 修饰符 static synchronized 返回值类型 方法名(方法参数) { 方法体；}
- 同步静态方法的锁对象
- 就是类名.class
- 代码实现
public class Demo {
public static void main(String[] args) {
MyRunnable mr = new MyRunnable();
Thread t1 = new Thread(mr);
Thread t2 = new Thread(mr);
t1.setName("窗口一");
t2.setName("窗口二");
t1.start();
t2.start();
}
}
class MyRunnable implements Runnable {
private static int ticketCount = 100;
@Override
public void run() {
while(true){
if("窗口一".equals(Thread.currentThread().getName())){
//同步方法
boolean result = synchronizedMthod();
if(result){
break;
}
}
if("窗口二".equals(Thread.currentThread().getName())){
//同步代码块
synchronized (MyRunnable.class){
if(ticketCount == 0){
break;
}else{
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
ticketCount--;
System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
}
}
}
}
}
private static synchronized boolean synchronizedMthod() {
if(ticketCount == 0){
return true;
}else{
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
ticketCount--;
System.out.println(Thread.currentThread()