线程基础03
6.用户线程和守护线程
-
用户线程:也叫工作线程,当线程的任务执行完或者通知方法结束。平时用到的普通线程均是用户线程,当在Java程序中创建一个线程,它就被称为用户线程
-
守护线程(Daemon):一般是为工作线程服务的,当所有的用户线程结束,守护线程自动结束
-
常见的守护线程:垃圾回收机制
例子1:如何将一个线程设置成守护线程
package li.thread.method; public class ThreadMethodExercise { public static void main(String[] args) throws InterruptedException { MyDaemonThread myDaemonThread = new MyDaemonThread(); //如果我们希望当主线程结束后,子线程自动结束,只需要将子线程设置为守护线程 myDaemonThread.setDaemon(true); myDaemonThread.start(); for (int i = 1; i <= 10; i++) {//main线程 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("八戒收拾东西回高老庄..."); } } }
7.线程的生命周期
- JDK中用Thread.State枚举表示了线程的几种状态:
例子
package li.thread.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 (t.getState() != Thread.State.TERMINATED) { 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() { for (int i = 0; i < 10; i++) { System.out.println("hi" + i); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }
8.线程同步机制
- 线程同步机制
- 在多线程编程中,一些敏感数据不允许被多个线程同时访问,此时就使用同步访问技术,保证数据在任何同一时刻,最多有一个线程访问,以保证数据的完整性。
- 也可以理解为:线程同步,即当有一个线程在对内存进行操作时,其他线程都不可以对这个内存地址进行操作,直到该线程完成操作,其他线程才能对该内存地址进行操作。
- 同步具体方法--Synchronized
-
同步代码块
synchronized(对象){//得到对象的锁,才能操作同步代码 //需要被同步的代码 } -
synchronized还可以放在方法声明中,表示整个方法为同步方法
public synchronized void m(String name){ //需要被同步的代码 } 就好像某个小伙伴上厕所之前先把门关上(上锁),完事之后再出来(解锁),那么其他小伙伴就可以再使用厕所了
例子:使用synchronized解决3.1售票问题
package li.thread.syn; //使用多线程,模拟三个窗口同时售票共100张 public class SynSellTicket { 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个线程-窗口 } } //实现接口方式,使用synchronized实现线程同步 class SellTicket03 implements Runnable { private int ticketNum = 100; private boolean loop = true;//控制run方法变量 public synchronized void sell() {//同步方法,在在同一时刻,只能有一个线程来执行run方法 if (ticketNum <= 0) { System.out.println("售票结束..."); loop = false; return; } //休眠50毫秒,模拟 try { Thread.sleep(50); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("窗口:" + Thread.currentThread().getName() + "售出一张票 " + "剩余票数:" + (--ticketNum)); } @Override public void run() { while (loop) { sell();//sell方法是一个同步方法 } } }
8.1互斥锁
- 基本介绍
- Java语言中,引入了对象互斥锁的概念,来保证共享数据操作的完整性
- 每一个对象都对应于一个可称为“互斥锁”的标记,这个标记用来保证在任一时刻,只能有一个线程访问该对象
- 关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时,表明该对象在任一时刻只能有一个线程访问
- 同步的局限性:导致程序的执行效率降低
- 非静态的同步方法,锁可以是this(当前对象),也可以是其他对象(要求锁的是同一个对象)
- 同步方法(静态的)的锁为当前类本身(类.class)
synchronized实现同步的基础:Java中的每一个对象都可以作为锁。
具体表现为以下3种形式。
对于普通同步方法,锁是当前实例对象。
对于静态同步方法,锁是当前类的Class对象。
对于同步方法块,锁是Synchonized括号里配置的对象。
- 注意事项和细节:
- 同步方法如果没有使用static修饰:默认锁对象为this
- 如果方法使用static修饰,默认锁对象:当前类.class
- 实现的落地步骤:
- 需要先分析上锁的代码
- 选择同步代码块或者同步方法
- 要求多个线程的锁对象为同一个
package li.thread.syn; //使用多线程,模拟三个窗口同时售票共100张 public class SynSellTicket { 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个线程-窗口 } } //实现接口方式,使用synchronized实现线程同步 class SellTicket03 implements Runnable { private int ticketNum = 100; private boolean loop = true;//控制run方法变量 Object object = new Object(); //1.public synchronized static void m1(){}的锁加在SellTicket03.class public synchronized static void m1(){} //2.如果在静态方法中,要实现一个同步代码块则应该这样写:(原因是静态方法适合类一起加载的,静态方法不能使用this) public static void m2(){ synchronized (SellTicket03.class){ System.out.println("m2"); } } // public synchronized void sell() {}就是一个同步方法。这时,锁在this对象 //也可以在代码块上写synchronized,同步代码块,互斥锁还是在this对象 public /*synchronized*/void sell() {//同步方法 synchronized (/*this*/object) {//如果是new Object就不是同一个对象 if (ticketNum <= 0) { System.out.println("售票结束..."); loop = false; return; } //休眠50毫秒,模拟 try { Thread.sleep(50); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("窗口:" + Thread.currentThread().getName() + "售出一张票 " + "剩余票数:" + (--ticketNum)); } } @Override public void run() { while (loop) { sell();//sell方法是一个同步方法 } } }
8.2线程的死锁
- 基本介绍:
多个线程都占用了对方的锁资源,但不肯相让,导致了死锁。
在编程中一定要避免死锁的发生。
例子:
package li.thread.syn; //模拟线程死锁 public class DeadLock_ { public static void main(String[] args) { //模拟死锁现象 DeadLockDemo A = new DeadLockDemo(true); DeadLockDemo B = new DeadLockDemo(false); A.setName("A线程"); 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为true,线程就会先得到/持有 o1对象锁,然后尝试去获取o2对象锁 //2.如果线程A得不到o2对象锁,就会Blocked //3.如果flag为false,线程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"); } } } } }
如下图:两个线程卡住了
8.3释放锁
下面操作会释放锁:
- 当前线程的同步方法、同步代码块执行结束
- 当前线程在同步代码块、同步方法中遇到break、return
- 当前线程在同步代码块、同步方法中出现了未处理的Error或者Exception,导致异常结束
- 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法,当前线程暂停,并释放锁
下面的操作不会释放锁:
-
线程执行同步代码块或同步方法时,程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行,不会释放锁
-
线程执行同步代码块时,其他线程调用了该线程的suspend()方法将该线程挂起,该线程不会释放锁。
提示:应尽量避免使用suspend()和resume()来控制线程,这两个方法不再推荐使用
9.本章作业
9.1线程HomeWork01
(1)在main方法中启动两个线程
(2)第一个线程循环随机打印100以内的整数
(3)直到第二个线程从键盘读取了“Q”命令
练习:
package li.thread.syn.homework; import java.util.Scanner; //(1)在main方法中启动两个线程 public class ThreadHomeWork01 { public static void main(String[] args) { A a = new A(); B b = new B(a);//注意把a对象传入b构造器中 a.start(); b.start(); } } //创建A线程类 class A extends Thread { private boolean loop = true; @Override public void run() { while (loop) { System.out.println((int) (Math.random() * 100 + 1)); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("a线程退出..."); } public void setLoop(boolean loop) { this.loop = loop; } } //创建B线程类 class B extends Thread { private A a; Scanner scanner = new Scanner(System.in); public B(A a) { this.a = a; } @Override public void run() { while (true) { //接到用户输入 System.out.println("请输入你的指令(Q)表示退出"); char key = scanner.next().toUpperCase().charAt(0); if (key == 'Q') { //以通知的方式结束a线程 a.setLoop(false); System.out.println("b线程退出..."); break; } } } }
9.2线程线程HomeWork02
(1)有两个用户分别从同一张卡上取钱(总额10000)
(2)每次都取1000,当余额不足时,就不能取款了
(3)不能出现超取现象==>线程同步问题
易错点:关于互斥锁的理解
对于普通同步方法,锁是当前实例对象。
对于静态同步方法,锁是当前类的Class对象。
对于同步方法块,锁是Synchonized括号里配置的对象
package li.thread.syn.homework; public class ThreadHomeWork02 { public static void main(String[] args) { T t = new T(); Thread thread1 = new Thread(t); Thread thread2 = new Thread(t); thread1.setName("t1"); thread2.setName("t2"); thread1.start(); thread2.start(); } } class T implements Runnable { private int money = 10000; @Override public void run() { while (true) {//while不要放到同步代码块里面 //1.使用了synchronized实现线程同步 //2.当多个线程执行到这里的时候就会去争夺 this对象锁 //3.哪个线程争夺到(获取)this对象锁,就执行synchronized代码块 //4.争夺不到this对象锁,就Blocked,准备继续争夺 //5.this对象锁是非公平锁 synchronized (this) { if (money <= 0) { System.out.println("余额不足..."); break; } money -= 1000; System.out.println(Thread.currentThread().getName() + "取出了1000元" + " 当前余额为:" + money); } try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }