Java线程基础
线程相关的概念
进程: 程序的一次执行过程,或是正在运行的一个程序为一个进程。是动态过程,因为它具备产生,存在,消亡的过程。
线程: 线程是由进程创建的,是进程的一个实体,一个进程可以有多个线程。例如:打开迅雷就是启动一个进程,迅雷开启一个文件下载任务就是开启一个线程。
- 单线程:同一个时刻,只允许执行一个线程
- 多线程:同一个时刻, 可以执行多个线程:例如QQ多个聊天窗口,迅雷多个文件下载
并发和并行
并发:
同一时间,多个任务交替执行,但具体的某一个时刻是只执行一个任务,造成一种“貌似同时”的错觉。简单来说:单核CPU要实现多个任务就是并发。
一个CPU在人类察觉不到时间粒度的情况下去来回切换这两个进程的执行。现实生活中例如:开车打电话,人不可能做到一个大脑在同一个时刻同时思考开车和接电话,而是因为大佬思考切换的速度我们意识不到,才看出来我们貌似是在”同时“。这种情况也叫:“宏观上并行,微观上并发”。
并行:
同一时刻,多个任务同时执行。
所谓并行,好比两人同时在两条线上向前移动,而不是一个人在两条线之前来回切换向前移动。简单说:就是多核CPU同时在执行进程。如果两个CPU分别在执行一个进程,那么就是并行执行。但是,一台多核电脑,也可以同时存在并发和并行,因为如果进程太多,单个CPU执行多进程的同时也和其他CPU并行执行。
线程基本使用
线程的创建:
在创建线程前,必须明白一点,运行main函数,就是开启一个进程。而随之会开启一个线程(main线程),而所写的方法就运行在线程上,方法可以在main线程中执行。也可以开启子线程,子线程也可以继续开启新的线程,并在其中执行其他方法。但是当进程开启后(main函数运行后),只有所有的线程(包括各类子线程等)运行结束之后,进程才会关闭。不要产生在只有当主线程(main)结束,进程就结束的想法。
方式一:继承Thread类
public class Thread01 {
public static void main(String[] args) {
Cat cat = new Cat();
//使用继承Thread的方式 创建线程 运行时:使用start()方法
cat.start();
System.out.println("主线程执行 线程名:"+Thread.currentThread().getName());
}
}
/**
* 创建线程的第一种方式:
* 继承Thread类
*/
class Cat extends Thread{
int time = 0;
// 重写父类(Thread)的run方法 该方法是开启线程后执行的内容
@Override
public void run() {
//该线程执行打印8次结束
while (time != 8){
System.out.println("喵喵~~~~"+(++time)+" 当前线程名:"+Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("子线程执行结束");
}
}
注意: 这里并不能直接调用重写Thread的run()方法。为什么?因为我们是在主线程当中调用重写的run()方法,因此没有新开辟线程让其运行,而是直接在主线程运行,代码向下顺序执行。
而start()方法,其本质是调用了本地的方法(Native method)start0(),它向 JVM 提交开启线程的申请,JVM向计算机系统请求分配资源开启线程并最终调用run()方法实现子线程中运行。
如果主线程(main)当中也有循环操作,可以在控制台中看到两个线程的打印结果是交错的,这就是多线程的并发。
方式二:实现Runable接口
java是单继承特性,某些情况下该类继承了其他类,此时如果创建线程就必须使用实现接口的方式。
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+1) +"===" + Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("主线程结束");
}
}
/**
* 线程创建方式二:实现 Runnable 接口
*/
class Dog implements Runnable{
int times = 0;
@Override
public void run() {
while (times != 10){
System.out.println("旺旺~~~~" + (++times) + "线程名:" + Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("子线程结束");
}
}
建议使用实现接口的方式创建线程。
经典售票问题
多线程卖票 出现超卖问题:
/**
* 多线程售票问题:
* 开辟三个线程同时售票(并发) 会出现超卖问题
*/
public class SellTicket {
public static void main(String[] args) {
Ticket ticket = new Ticket();
new Thread(ticket).start();
new Thread(ticket).start();
new Thread(ticket).start();
}
}
class Ticket implements Runnable{
//由于实现接口方式创建的线程其启用多个线程是共享资源的,不需要total为静态变量
private int total = 100;
@Override
public void run() {
while(true){
if (total <=0 ){
System.out.println("窗口:"+Thread.currentThread().getName()+"售票结束===剩余:"+total);
break;
}
//线程休眠50ms模拟操作的时间
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
//模拟卖票
System.out.println("窗口:"+Thread.currentThread().getName()+"卖出一张票=====剩余:"+(--total));
}
}
}
问题:
为什么会出现剩余票数不同步和超卖问题呢?
原因:因为多线程会导致三个线程出现同时读取票数进行操作的情况,于是可能出现 Thread0读取票数 准备减去票数前被Thread1读取该票数并操作,那么读取的是同一个票数,并且都卖出去了一张,如果此时只剩1张票,被三个线程都读取:一个线程卖完为0,而其它两个先后由于读取时候为1,通过了售票条件,在操作时都减一,就会出现多卖2张,结果-2。
如何解决? 上锁
线程结束
线程如何结束?在开启线程执行任务时,会在run()方法中开启while循环,将循环条件设置为boolean值,并生成set方法,即可在外部通过set该条件值控制线程结束。
public class ThreadEnd {
public static void main(String[] args) {
Task task = new Task();
new Thread(task).start();
//主线程休眠6s后结束子线程
try {
Thread.sleep(6000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//结束线程中的循环体
task.setStarted(false);
}
}
class Task implements Runnable{
private int count = 0;
private boolean started = true;
@Override
public void run() {
while(started){
System.out.println("任务执行:"+(++count));
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("子线程已结束");
}
public void setStarted(boolean started) {
this.started = started;
}
}
线程中断
什么是中断?中断不是指线程结束,而是中断异常。例如在线程休眠过程中触发中断,就会进入中断异常。一般用于:中断正在休眠的进程。
public class ThreadInterrupt {
public static void main(String[] args) throws InterruptedException {
Task01 task01 = new Task01();
Thread thread = new Thread(task01);
thread.start();
//5s后中断线程
for (int i = 0; i < 5; i++) {
Thread.sleep(1000);
System.out.println("子线程休息:"+(i+1)+"s");
}
//中断子线程休眠 继续执行任务
thread.interrupt();
}
}
class Task01 implements Runnable{
int count = 0;
@Override
public void run() {
while (true){
System.out.println("任务执行:"+(++count));
//线程准备休眠10s
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
System.out.println("子线程"+Thread.currentThread().getName()+"被中断了");
}
}
}
}
线程插队
-
yield()
该方法称为线程礼让。即让出占用的CPU资源,让其他线程执行。但是,礼让的时间不确定,也不一定能礼让成功。如果CPU资源紧张,那么大概率成功,如果CPU完全充足,那么CPU也不会使其礼让成功。
例如:CPU并发执行两个线程,如果Thread0调用yield() ,可能CPU会优先执行Thread 1。
-
join()
如图:join方法插队,Thread 0 中执行 t1.join() 意味着 在 Thread 0 线程执行到该方法时插入 Thread 1,当Thread 1执行完结束之后才能执行 Thread 0。
例如 主线程 中执行子线程 join(),只有当子线程结束后,主线程才能继续执行。
public class ThreadJoin {
public static void main(String[] args) {
Task02 task02 = new Task02();
Thread thread = new Thread(task02);
thread.start();
for (int i = 0; i < 20; i++) {
if (i == 5){
try {
//线程插队
//thread.join();
//线程礼让
Thread.yield();//main礼让子线程 cpu资源充分的情况下一般失效
} catch (Exception e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+"执行:"+(i+1));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Task02 implements Runnable{
int count = 0;
@Override
public void run() {
while(count != 20){
System.out.println(Thread.currentThread().getName()+"执行:"+(++count));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("子线程结束");
}
}
守护线程
守护线程:为工作线程服务的线程,当所有的用户线程结束,守护线程自动结束。利用守护线程可以去实现监视其它用户线程等功能
经典的守护线程:垃圾回收机制
守护线程必须在start()之前设置Daemon
示例:
Task03 task03 = new Task03();
Thread thread = new Thread(task03);
thread.setDaemon(true); //设置为守护线程
thread.start();
线程生命周期
图为重点
Synchronized
线程同步机制
- 在多线程编程,一些敏感数据不允许被多个线程同时访问,此时就使用同步访问技术,保证数据在同一时刻,最多有一个线程访问,以保证数据的完整性。
- 也可以这里理解:线程同步,即当有一个线程在对内存进行操作时,其他线程都不可以对这个内存地址进行操作,直到该线程完成操作,其他线程才能对该内存地址进行操作。
同步方法
同步具体方法-Synchronized
1.同步代码块
synchronized(对象){//得到对象的锁,才能操作同步代码
//需要被同步代码
}
2.synchronized还可以放在方法声明中,表示整个方法-为同步方法
public synchronized void m(String name){
//需要被同步的代码
}
互斥锁
1.Java语言中,引入了对象互斥锁的概念,来保证共享数据操作的完整性,
2.每个对象都对应于一个可称为“互斥锁”的标记,这个标记用来保证在任一时刻,只能有一个线程访问该对象。
3.关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时,表明该对象在任一时刻只能由一个线程访问。
4.同步的局限性:导致程序的执行效率要降低(因为原本多线程却由于同步上锁导致执行受到阻塞)
5.同步方法(非静态的)的锁可以是this,也可以是其他对象(要求是同一个对象)
6.同步方法(静态的)的锁为当前类本身。
利用互斥锁同步方法解决售票问题
-
在需要同步的方法上加锁:
private synchronized void sell()
,此时锁仍然在this对象上,也就是Tikek02的实例化对象上我们使用实现接口的方式创建的线程,是通过一个实例化对象来创建多线程,共享的是同一资源。因此在方法上加锁是可行的。因为是同一实例对象的方法。
-
**在需要同步的代码块上加锁:**代码块上加锁 实现线程同步 注意这里锁对象仍然是this 而三个线程都是该同一个对象锁 因此同步有效
方法同步资源开销比代码块大,因此优先考虑代码块加锁
-
**注意:**要实现上锁同步,必须确保锁在同一个对象,可以是this,也可以是其他对象,但必须多线程在同一个对象锁。例如:在方式二中声明一个object对象,把代码块锁的this对象换成object,也同样有效,因为三个线程都共用一个对象锁。
例如:使用继承类方式创建线程,既不能在方法上加锁,也不能代码块加锁传入this对象,而可以创建static类型的object对象从而锁加在同一个对象上。
/** * 使用继承的方式创建多线线程 尝试解决售票问题 注意事项: * 1. 继承的方式每个线程实例化对象不一样,那么不能在方法上 */ class Ticket03 extends Thread { private static int total = 200; private static Object object = new Object(); private boolean loop = true; private synchronized void sell(){ //给方法上锁 也不会同步 方法上锁是给this对象上锁,而在继承Thread类创建线程时,每次的实例对象(this)不一样 if (total <= 0) { System.out.println("窗口:" + Thread.currentThread().getName() + "售票结束===剩余:" + total); loop = false; return; } //模拟卖票 System.out.println("窗口:" + Thread.currentThread().getName() + "卖出一张票=====剩余:" + (--total)); //线程休眠50ms模拟操作的时间 try { Thread.sleep(50); } catch (InterruptedException e) { e.printStackTrace(); } } @Override public void run() { while (true /*loop*/) { synchronized (object){ //代码块加锁,共享object对象上锁是可以同步的,而this不行 if (total <= 0) { System.out.println("窗口:" + Thread.currentThread().getName() + "售票结束===剩余:" + total); break; } //模拟卖票 System.out.println("窗口:" + Thread.currentThread().getName() + "卖出一张票=====剩余:" + (--total)); //线程休眠10ms模拟操作的时间 try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } } //sell(); } } }
-
如果在静态方法上加锁,锁加在类的本身而不是this对象:因为static会在对象初始化之前就加载,因此静态方法中是找不到this对象的。因此是可以在静态方法上加锁也可以在代码块中加锁,但是必须是类本身。
public synchronized static void m1(){...}//锁在 xxx.class public static void m2(){ ... synchronized(xxx.class){ //必须是类本身 ... } }
//方式一:
class Ticket02 implements Runnable {
//由于实现接口方式创建的线程其启用多个线程是共享资源的,不需要total为静态变量
private int total = 100;
private synchronized void sell() { //加锁 实现线程同步 (方法上加锁)
if (total <= 0) {
System.out.println("窗口:" + Thread.currentThread().getName() + "售票结束===剩余:" + total);
return;
}
//线程休眠50ms模拟操作的时间
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
//模拟卖票
System.out.println("窗口:" + Thread.currentThread().getName() + "卖出一张票=====剩余:" + (--total));
}
@Override
public void run() {
while(total != 0){
sell();
}
}
}
//方式二:
class Ticket02 implements Runnable {
//由于实现接口方式创建的线程其启用多个线程是共享资源的,不需要total为静态变量
private int total = 100;
private void sell() {
synchronized (this){ //代码块上加锁 实现线程同步 注意这里锁对象仍然是this 而三个线程都是该同一个对象锁 因此有效
//模拟卖票
System.out.println("窗口:" + Thread.currentThread().getName() + "卖出一张票=====剩余:" + (--total));
}
//线程休眠50ms模拟操作的时间
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Override
public void run() {
while(total != 0){
sell();
}
System.out.println(Thread.currentThread().getName()+"售票结束! 剩余:"+total);
}
}
死锁
概念:多个线程都占用对方锁资源,但是都不肯释放,导致死锁。例如:A对B说:你把货先给我,我在给钱。B对A说:你先把钱给我,我再给你货。
模拟死锁
/**
* 模拟死锁的发生
*/
public class DeadLock {
public static void main(String[] args) {
Exam exam1 = new Exam(true);
exam1.setName("A线程");
exam1.start();
Exam exam2 = new Exam(false);
exam2.setName("B线程");
exam2.start();
}
}
//测试死锁类
class Exam extends Thread{
//创建两个锁对象,为了加锁同步
static Object o1 = new Object();
static Object o2 = new Object();
//由flag控制对应的线程执行对应的代码
boolean flag = true;
//构造函数传入flag
public Exam(boolean flag){
this.flag = flag;
}
@Override
public void run() {
/**
* 代码逻辑分析:
* 1.如果flag为true,A线程先占用o1锁,执行任务,再占用o2锁,才能继续执行下去
* 2.如果flag为false,B线程先占用哦o2锁,执行任务,再占用o1锁,才能继续执行下去
* 3.如果AB都执行,会使得A占用了o1锁但是无法获取o2锁而释放不了o1;而B占用了o2锁但是无法获取o1锁而释放不了o2 造成死锁
*/
if (flag){
synchronized (o1){
System.out.println("A占用O1锁中~");
synchronized (o2){
System.out.println("A占用O2锁中~");
}
}
}else{
synchronized (o2){
System.out.println("B占用O2锁中~");
synchronized (o1){
System.out.println("B占用O1锁中~");
}
}
}
}
}
释放锁
下面操作会释放锁
-
当前线程的同步方法、同步代码块执行结束
-
当前线程在同步代码块、同步方法中遇到break、return。
-
当前线程在同步代码块、同步方法中出现了未处理的Error或Exception,导致异常结束
-
当前线程在同步代码块、同步方法中执行了线程对象的wait()方法,当前线程暂停,并释放锁。
下面操作不会释放锁
- 线程执行同步代码块或同步方法时,程序调Thread.sleep()、Thread.yield()方法暂停当前线程的执行,不会释放锁。
- 线程执行同步代码块时,其他线程调用了该线程的suspend0方法将该线程挂起,该线程不会释放锁。
提示:应尽量避免使用suspend()和resume()来控制线程,方法不再推荐使用
练习
-
两用户取钱,线程同步问题
/** * 两个用户分别从同一个卡上取钱(10000) * 每次都取1000,不能出现超取。 */ public class Test01 { public static void main(String[] args) { TakeMoney takeMoney = new TakeMoney(); new Thread(takeMoney, "用户A").start(); new Thread(takeMoney, "用户B").start(); } } class TakeMoney implements Runnable { private int total = 10000; @Override public void run() { while (true) { synchronized (this) { //给对象上锁 该锁为非公平锁(获得锁并操作完之后释放后继续参与锁的获取,所以非公平) if (total <= 0) { System.out.println("ATM余额:" + total); return; } //取钱 total -= 1000; System.out.println(Thread.currentThread().getName() + "取:1000,ATM剩余:" + total); } try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }
-
两线程执行,一个线程通知另外一个停止
/** * (1)在main方法中启动两个线程 * (2)在一个线程循环随机打印100以内的整数 * (3)直到第二个线程从键盘读取了"Q"命令后两个线程结束 */ public class Test02 { public static void main(String[] args) { Work01 work01 = new Work01(); Thread thread1 = new Thread(work01, "线程1"); thread1.start(); Work02 work02 = new Work02(work01); Thread thread2 = new Thread(work02, "线程2"); thread2.setDaemon(true);//这里只有两个子线程 可以开启守护线程,如果多个线程执行,要考虑自身线程如何结束的条件。 thread2.start(); } } class Work01 implements Runnable { int count = 0; private boolean started = true; public void setStarted(boolean started) { this.started = started; } @Override public void run() { while (started) { int number = (int) (Math.random() * 100);//100以内 System.out.println(Thread.currentThread().getName() + ":输出:" + number + " 次数:" + (++count)); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("线程1:任务停止"); } } class Work02 implements Runnable { private Work01 work01; public Work02(Work01 work01) { this.work01 = work01; } @Override public void run() { //接收输入键盘命令 Q while (true) { System.out.println(Thread.currentThread().getName() + "等待接收命令(Q)"); Scanner scanner = new Scanner(System.in); while (scanner.hasNext()) { String cmd = scanner.next(); if (cmd.equalsIgnoreCase("q")) { work01.setStarted(false); } else { break; } } } } }