多线程基础
1. 线程相关概念
1.1 程序(program)
最为简单完成特点任务,用某种语言编写的一组指令的集合.
最简单的说:就是我们写的代码
1.2 进程
1.进程是指运行中的程序,比如我们使用QQ,就启动了一个进程,操作系统就会为该进程分配内存空间。当我们使用迅雷,又启动了一个进程,操作系统将为迅雷分配新的内存空间。
2.进程是程序的一次执行过程,或是正在运行的一个程序。是动态过程:有它自身的产生、存在和消亡的过程
1.3 什么是线程
1.线程由进程创建的,是进程的一个实体
2.一个进程可以拥有多个线程,如下图
1.4 其他相关概念
1.单线程:同一个时刻,只允许执行一个线程
2.多线程:同一个时刻,可以执行多个线程,比如:一个qq进程,可以同时打开多个聊天窗口,一个迅雷进程,可以同时下载多个文件
3.并发:同一个时刻,多个任务交替执行,造成一种“貌似同时”的错觉,简单的说,单核cpu实现的多任务就是并发。
4.并行:同一个时刻,多个任务同时执行。多核cpu可以实现并行。并发和并行
2. 线程基本使用
2.1 创建线程的两种方式
在java中线程来使用有两种方法。
1.继承Thread类,重写run方法
2.实现Runnable接口,重写run方法
2.2 线程应用案例 1-继承 Thread 类
创建Thread01.java com.yujianedu.threaduse
1)请编写程序,开启一个线程,该线程每隔1秒。在控制台输出“喵喵,我是小猫咪”
2)对上题改进:当输出80次喵喵,我是小猫咪,结束该线程
3)使用JConsole 监控线程执行情况,并画出程序示意图!
当你在运行一个多线程程序的时候,假如你的主线程已经结束,如果该主线程下还有子线程在运行,就不会导致整个程序的结束(当所有的线程都结束了才会导致程序结束).
代码如下:
package com.yujianedu.threaduse;
/**
* 演示通过继承 Thread 类创建线程
*/
public class Thread01 {
public static void main(String[] args) throws InterruptedException {
//创建 Cat 对象,可以当做线程使用
Cat cat = new Cat();
/*
//start0() 是本地方法,是 JVM 调用, 底层是 c/c++实现
//真正实现多线程的效果, 是 start0(), 而不是 run
private native void start0();
*/
cat.start(); //启动线程-> 最终会执行 cat 的 run 方法
//cat.run();//run 方法就是一个普通的方法, 没有真正的启动一个线程,就会把 run 方法执行完毕,才向下执行
//说明: 当 main 线程启动一个子线程 Thread-0, 主线程不会阻塞, 会继续执行
//这时 主线程和子线程是交替执行.. System.out.println("主线程继续执行" + Thread.currentThread().getName());//名字 main
for(int i = 0; i < 60; i++) {
System.out.println("主线程 i=" + i);
//让主线程休眠
Thread.sleep(1000);
}
}
}
//老韩说明
//1. 当一个类继承了 Thread 类, 该类就可以当做线程使用
//2. 我们会重写 run 方法,写上自己的业务代码
//3. run Thread 类 实现了 Runnable 接口的 run 方法
class Cat extends Thread{
@Override
public void run() { //重写 run 方法,写上自己的业务逻辑
int times = 0;
while (true){
//该线程每隔 1 秒。在控制台输出 “喵喵, 我是小猫咪"
System.out.println("喵喵,我是小妈咪"+(++times)+ " 线程名=" + Thread.currentThread().getName());
//让该线程休眠 1 秒
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (times == 8){
break; //当 times 到 80, 退出 while, 这时线程也就退出
}
}
}
}
执行结果:
2.3 线程应用案例 2-实现 Runnable 接口
-
说明
- java是单继承的,在某些情况下一个类可能已经继承了某个父类,这时在用继承Thread类方法来创建线程显然不可能了。
- java设计者们提供了另外一个方式创建线程,就是通过实现Runnable接口来创建线程
-
应用案例
请编写程序,该程序可以每隔1秒。在控制台输出“hi!”,当输出10次后,自动退出。请使用实现Runnable接口的方式实现。Thread02.,java,这里底层使用了设计模式[代理模式]=>代码模拟实现Runnable接口开发线程的机制 -
代码如下:
package com.yujianedu.threaduse;
/**
* 通过实现Runnable 来开发线程
*/
public class Thread02 {
public static void main(String[] args) {
Dog dog = new Dog();
Thread thread = new Thread(dog);
thread.start();
for (int i = 0; i < 10; i++) {
System.out.println("主线程正在运行"+ i);
}
}
}
class Dog implements Runnable{
int count = 0;
@Override
public void run() {
while (true){
System.out.println("小狗汪汪叫~~hi" + (++count) +Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (count == 10){
break;
}
}
}
}
执行结果:
2.4 线程使用应用案例-多线程执行
请编写一个程序,创建两个线程,一个线程每隔1秒输出“hello,world",输出10次,退出,一个线程每隔1秒输出“hi”,输出5次退出.Thread03.java
package com.yujianedu.threaduse;
public class Thread03 {
public static void main(String[] args) {
T1 t1 = new T1();
T2 t2 = new T2();
Thread t1Thread = new Thread(t1);
Thread t2Thread = new Thread(t2);
t1Thread.start();
t2Thread.start();
}
}
class T1 implements Runnable{
@Override
public void run() {
int count = 0;
while (true){
System.out.println("hello,world"+ (++count));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (count == 10){
break;
}
}
}
}
class T2 implements Runnable{
@Override
public void run() {
int count = 0;
while (true){
System.out.println("hi"+ (++count));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (count == 5){
break;
}
}
}
}
运行结果:
2.5 线程如何理解
3. 继承 Thread vs 实现 Runnable 的区别
1.从java的设计来看,通过继承Thread或者实现Runnable接口来创建线程本质上没有区别,从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口
2.实现Runnable接口方式更加适合多个线程共享一个资源的情况,并且避免了单继承的限制,建议使用Runnable
3.[售票系统],编程模拟三个售票窗口售票100,分别使用继承Thread 和实现Runnable方式,并分析有什么问题?SellTicket.java
代码如下:
package com.yujianedu.ticket;
/**
* 使用多线程,模拟三个窗口同时售票 100 张
*/
public class SellTicket {
public static void main(String[] args) {
//测试
//SellTicket01 sellTicket01 = new SellTicket01();
//SellTicket01 sellTicket02 = new SellTicket01();
//SellTicket01 sellTicket03 = new SellTicket01();
//这里我们会出现超卖.
//sellTicket01.start();
//sellTicket02.start();
//sellTicket03.start();
System.out.println("===使用实现接口方式来售票=====");
SellTicket02 sellTicket02 = new SellTicket02();
new Thread(sellTicket02).start();//第 1 个线程-窗口
new Thread(sellTicket02).start();//第 2 个线程-窗口
new Thread(sellTicket02).start();//第 3 个线程-窗口
}
}
//使用 Thread 方式
class SellTicket01 extends Thread{
private static int ticketNum = 100; //让多个线程共享 ticketNum
@Override
public void run() {
while (true){
if (ticketNum <= 0){
System.out.println("售票结束...");
break;
}
//休眠 50 毫秒, 模拟
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票" + " 剩余票数=" + (--ticketNum));
}
}
}
class SellTicket02 extends Thread{
private int ticketNum = 100;
@Override
public void run() {
while (true){
if (ticketNum <= 0){
System.out.println("售票结束...");
break;
}
System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票" + " 剩余票数=" + (--ticketNum));
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
执行结果:
不管是使用继续Thread类或者实现Runnable接口,都会出现超卖
4. 线程终止
4.1 基本说明
1.当线程完成任务后,会自动退出。
2.还可以通过使用变量来控制run方法退出的方式停止线程,即通知方式
4.2 应用案例 ThreadExit_.java com.hspedu.exit_
需求:启动一个线程t,要求在main线程中去停止线程t,请编程实现.
代码如下:
package com.yujianedu.exit_;
public class ThreadExit_ {
public static void main(String[] args) throws InterruptedException {
T1 t1 = new T1();
t1.start();
System.out.println("main线程休息五秒");
//如果希望main线程去控制t1进程的终止,可以去修改loop
//让t1 退出run方法,从而终止 t1进程 -> 通知方式
Thread.sleep(1000 * 5);
t1.setLoop(false);
}
}
class T1 extends Thread{
private int count = 0;
//设置一个控制遍历(让其他的进程可以来控制这个进程)
private boolean loop = true;
@Override
public void run() {
while (loop){
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("T 正在运行中..."+(++count));
}
}
public void setLoop(boolean loop){
this.loop = loop;
}
}
执行结果:
在代码运行开始,5秒后由主线程终止了t1进程
5. 线程常用方法
5.1 常用方法第一组
1.setName//设置线程名称,使之与参数 name相同
2.getName//返回该线程的名称
3.start// 使该线程开始执行;Java虚拟机底层调用该线程的 start0方法
4.run//调用线程对象run方法;
5.setPriority//更改线程的优先级
6.getPriority//获取线程的优先级
7.sleep/在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)
8.interrupt //中断线程
5.3 注意事项和细节
1.start 底层会创建新的线程,调用run,run就是一个简单的方法调用,不会启动新线程
2.线程优先级的范围
3.interrupt,中断线程,但并没有真正的结束线程。所以一般用于中断正在休眠线程
4.sleep:线程的静态方法,使当前线程休眠
5.3 应用案例 ThreadMethod01.java
代码如下:
package com.yujianedu.mtthod_;
public class ThreadMethod {
public static void main(String[] args) throws InterruptedException {
T t = new T();
t.setName("yujian");
t.setPriority(Thread.MIN_PRIORITY);
t.start();
//测试优先级
System.out.println("默认优先级"+Thread.currentThread().getPriority());
//测试Interrupt,主线程休息5秒就让T中断sleep
for (int i = 0; i < 5; i++) {
Thread.sleep(1000);
System.out.println("hi"+i);
}
t.interrupt();
}
}
class T extends Thread{
private int count = 0;
@Override
public void run() {
while (true){
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+ "吃包子~~~~~");
}
System.out.println(Thread.currentThread().getName()+ "休眠中~~~~~");
try {
Thread.sleep(20000);
} catch (InterruptedException e) {
System.out.println(Thread.currentThread().getName()+ "被Interrupt了~~~~~");
}
}
}
}
5.4 常用方法第二组
1.yield:线程的礼让。让出cpu,让其他线程执行,但礼让的时间不确定,所以也不一定礼让成功
2.join:线程的插队。插队的线程一旦插队成功,则肯定先执行完插入的线程所有的任务
案例:main线程创建一个子线程,每隔1s输出hello,输出20次,主线程每隔1秒,输出hi,输出20次.要求:
两个线程同时执行,当主线程输出5次后,就让子线程运行完毕,主线程再继续.
5.5 应用案例
ThreadMethod02.java
测试 yield 和 join 方法 ,注意体会方法的特点,看老师代码演示
package com.yujianedu.mtthod_;
public class ThreadMthod02 {
public static void main(String[] args) throws InterruptedException {
T2 t2 = new T2();
t2.start();
for (int i = 1; i < 20; i++) {
Thread.sleep(1000);
System.out.println("主线程(老爸)吃了" + i + "个包子");
if (i==5){
System.out.println("主线程(老爸) 让 子线程(儿子)先吃完所有包子");
//join : 线程插队
t2.join();
System.out.println("子线程(儿子) 吃完了,主线程(老爸)开始吃");
}
}
}
}
class T2 extends Thread{
@Override
public void run() {
for (int i = 1; i < 20; i++) {
try {
Thread.sleep(1000); //休眠一秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("子线程(儿子)吃了" + i + "个包子");
}
}
}
5.6 课堂练习
ThreadMethodExercise.java 5min
1.主线程每隔1s,输出hi,一共10次
2.当输出到hi5时,启动一个子线程(要求实现Runnable),每隔1s输出hello,等该线程输出10次hello后,退出
3.主线程继续输出hi,直到主线程退出.
4.如图,完成代码其实线程插队..
5.代码如下
package com.yujianedu.mtthod_;
public class ThreadMethodExercise {
public static void main(String[] args) throws InterruptedException {
for (int i = 1; i < 10; i++) {
Thread.sleep(1000);
System.out.println("h1"+i);
if (i == 5){ //说明主线程输出了 5 次 hi
SonThread sonThread = new SonThread();
Thread thread = new Thread(sonThread);
thread.start(); // 启动子线程 输出 hello...
thread.join();//立即将 t3 子线程,插入到 main 线程,让 t3 先执行
}
}
}
}
class SonThread implements Runnable{
@Override
public void run() {
for (int i = 1;i<=10;i++){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("hello"+i);
}
}
}
6.执行结果:
5.7 用户线程和守护线程
1.用户线程:也叫工作线程,当线程的任务执行完或通知方式结束
2.守护线程:一般是为工作线程服务的,当所有的用户线程结束,守护线程自动结束
3.常见的守护线程:垃圾回收机制
5.8 应用案例 ThreadMethod03.java
下面我们测试如何将一个线程设置成守护线程
package com.yujianedu.mtthod_;
public class ThreadMethod03 {
public static void main(String[] args) throws InterruptedException {
MyDaemonThread myDaemonThread = new MyDaemonThread();
//如果我们希望当我们主线程结束后,子进程自动结束
//只需将子线程设置为守护进程
myDaemonThread.setDaemon(true);
myDaemonThread.start();
for (int i = 1; i <= 10; i++) {
System.out.println("宝强辛苦的工作");
Thread.sleep(1000);
}
}
}
class MyDaemonThread extends Thread{
@Override
public void run(){
for ( ; ;){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("马蓉和宋集快乐聊天~~~");
}
}
}
当主线程运行完毕后,假如此时此线程还没有运行结束(也会被强制停止)
6. 线程的生命周期
6.1 JDK 中用 Thread.State 枚举表示了线程的几种状态
6.2 线程状态转换图
6.3 写程序查看线程状态 ThreadState_.java
代码如下
package com.yujianedu.state_;
public class ThreadState_ {
public static void main(String[] args) throws InterruptedException {
T t = new T();
System.out.println(t.getName() + "状态" + t.getState());
t.start();
//当线程状态不等于终止状态就一直运行
while (Thread.State.TERMINATED != t.getState()){
System.out.println(t.getName() + "状态" + t.getState());
Thread.sleep(1000);
}
System.out.println(t.getName() + "状态" + t.getState());
}
}
class T extends Thread{
@Override
public void run() {
while (true){
for (int i = 0; i < 10; i++) {
System.out.println("hi " + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
break;
}
}
}
执行结果:
Thread-0状态NEW
Thread-0状态RUNNABLE
hi 0
Thread-0状态TIMED_WAITING
hi 1
Thread-0状态TIMED_WAITING
hi 2
Thread-0状态TIMED_WAITING
hi 3
Thread-0状态TIMED_WAITING
hi 4
Thread-0状态TIMED_WAITING
hi 5
Thread-0状态TIMED_WAITING
hi 6
Thread-0状态TIMED_WAITING
hi 7
Thread-0状态TIMED_WAITING
hi 8
Thread-0状态TIMED_WAITING
hi 9
Thread-0状态TIMED_WAITING
Thread-0状态TERMINATED
7. 线程的同步
7.1 先看一个问题
8. Synchronized
8.1 线程同步机制
1.在多线程编程,一些敏感数据不允许被多个线程同时访问,此时就使用同步访问技术,保证数据在任何同一时刻,最多有一个线程访问,以保证数据的完整性。
2.也可以这里理解:线程同步,即当有一个线程在对内存进行操作时,其他线程都不可以对这个内存地址进行操作,直到该线程完成操作,其他线程才能对该内存地址进行操作。
8.2 同步具体方法-Synchronized
9. 分析同步原理
10. 互斥锁
10.1 基本介绍
1.Java语言中,引入了对象互斥锁的概念,来保证共享数据操作的完整性。
2.每个对象都对应于一个可称为“互斥锁”的标记,这个标记用来保证在任一时刻,只能有一个线程访问该对象。
3.关键字synchronized 来与对象的互斥锁联系。当某个对象用synchronized修饰时,表明该对象在任一时刻只能由一个线程访问
4.同步的局限性:导致程序的执行效率要降低
5.同步方法(非静态的)的锁可以是this,也可以是其他对象(要求是同一个对象)
6.同步方法(静态的)的锁为当前类本身。
10.2 使用互斥锁来解决售票问题
代码如下:
package com.yujianedu.sync;
/**
* 使用多线程,模拟三个窗口同时售票 100 张(使用线程同步,让其不会超卖)
*/
public class SellTicket {
public static void main(String[] args) {
SellTicket03 sellTicket03 = new SellTicket03();
new Thread(sellTicket03).start();//第 1 个线程-窗口
new Thread(sellTicket03).start();//第 2 个线程-窗口
new Thread(sellTicket03).start();//第 3 个线程-窗口
}
}
class SellTicket03 implements Runnable {
private int ticketNum = 100;
//注意:
//1.public synchronized void m1(){} ,这里的锁是加在 SellTicket03.class 上的
public synchronized static void m1(){
}
public static void m2(){
synchronized (SellTicket03.class){ //在静态方法中,同步代码块中也是加入该类
System.out.println("m2");
}
}
// 1.private synchronized void sell() {}这是一个同步方法
// 2.这时锁在 this对象上
// 3.也可以在代码块上写 synchronized ,同步代码块
private /*synchronized*/ void sell() { //同步方法,在同一时刻,只能有一个线程执行sell方法
synchronized (this){
if (ticketNum <= 0) {
System.out.println("售票结束...");
return;
}
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票" + " 剩余票数=" + (--ticketNum));
}
}
@Override
public void run() {
while (ticketNum > 0) {
sell();
}
}
}
执行结果:
10.3 注意事项和细节
1.同步方法如果没有使用static修饰:默认锁对象为this
2.如果方法使用static修饰,默认锁对象:当前类.class
3.实现的落地步骤:
- 需要先分析上锁的代码
- 选择同步代码块或同步方法
- 要求多个线程的锁对象为同一个即可!
11. 线程的死锁
11.1 基本介绍
多个线程都占用了对方的锁资源,但不肯相让,导致了死锁,在编程是一定要避免死锁的发生.
11.2 应用案例
11.3 应用案例 DeadLock_.java
package com.yujianedu.sync;
public class DeadLock_ {
public static void main(String[] args) {
//模拟死锁现象
DeadLockDemo A = new DeadLockDemo(true);
A.setName("A 线程");
DeadLockDemo B = new DeadLockDemo(false);
B.setName("B 线程");
A.start();
B.start();
}
}
class DeadLockDemo extends Thread {
static Object o1 = new Object();// 保证多线程,共享一个对象,这里使用 static
static Object o2 = new Object();
boolean flag;
public DeadLockDemo(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) { // 这里获得 li 对象的监视权
System.out.println(Thread.currentThread().getName() + " 进入 2");
}
}
} else {
synchronized (o2) {
System.out.println(Thread.currentThread().getName() + " 进入 3");
synchronized (o1) { // 这里获得 li 对象的监视权
System.out.println(Thread.currentThread().getName() + " 进入 4");
}
}
}
}
}
执行结果:线程会一直卡着
12. 释放锁
12.1 下面操作会释放锁
1.当前线程的同步方法、同步代码块执行结束
案例:上厕所,完事出来
2.当前线程在同步代码块、同步方法中遇到break、return。
案例:没有正常的完事,经理叫他修改bug,不得已出来
3.当前线程在同步代码块、同步方法中出现了未处理的Error或Exception,导致异常结束 案例:没有正常的完事,发现忘带纸,不得已出来
4.当前线程在同步代码块、同步方法中执行了线程对象的wait()方法,当前线程暂停,并释放锁。
案例:没有正常完事,觉得需要酝酿下,所以出来等会再进去
12.2 下面操作不会释放锁
1.线程执行同步代码块或同步方法时,程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行,不会释放锁
案例:上厕所,太困了,在坑位上眯了一会
2.线程执行同步代码块时,其他线程调用了该线程的suspend()方法将该线程挂起,该线程不会释放锁。
提示:应尽量避免使用suspend()和resume()来控制线程,方法不再推荐使用
13. 本章作业
思路分析:
代码如下:
package com.yujianedu.homework;
import java.util.Scanner;
public class HomeWork01 {
public static void main(String[] args) {
A a = new A();
B b = new B(a);
a.start();
b.start();
}
}
class A extends Thread{
private boolean loop = true;
public void setLoop(boolean loop) {
this.loop = loop;
}
@Override
public void run() {
//输出1-100的数
while (loop){
System.out.println((int) (Math.random() * 100 +1 ));
//休眠
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("a线程退出...");
}
}
class B extends Thread{
private A a;
private Scanner in = new Scanner(System.in);
public B(A a){ //构造器中,直接传入A对象
this.a = a;
}
@Override
public void run() {
//接收用户的输入
System.out.println("请输入你的指令(Q),表示退出:");
while (true){
char key = in.next().toUpperCase().charAt(0);
if (key == 'Q'){
//以通知的方式结束a线程
a.setLoop(false);
System.out.println("b进程退出.");
break;
}
}
}
}
执行结果:
代码如下:
package com.yujianedu.homework;
public class Homewok02 {
public static void main(String[] args) {
bank bank = new bank();
new Thread(bank).start();
new Thread(bank).start();
}
}
class bank implements Runnable {
private int price = 10000;
@Override
public void run() {
while (true) {
//解读
//1. 这里使用 synchronized 实现了线程同步
//2. 当多个线程执行到这里时,就会去争夺 this对象锁
//3.哪个线程争夺到线程锁,就执行 synchronize 代码块,执行完后,会释放this对象锁
//4.争夺不到this对象锁,就blocked,准备继续争夺
//5. this对象锁是非公平锁
synchronized (this) {
//判断余额是否够
if (price >= 1000) {
System.out.println("线程" + Thread.currentThread().getName() + "取走了1000元");
System.out.println("当前银行卡还剩下:" + (price -= 1000));
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
System.out.println("银行卡余额不足...");
break;
}
}
}
}
}
执行结果: