1.线程相关概念
1.1 程序(program)
是为完成特定任务、用某种语言编写的一组指令的集合。
简单地说：就是我们写的代码
1.2 进程
-
进程是指运行中的程序，比如我们使用qq就启动了一个进程，操作系统会为该进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统将为迅雷分配新的内存空间。
-
进程是程序的一次执行过程，或是正在运行的一个程序，是动态过程：有它自身的产生、存在和消亡的过程
1.3 线程
-
线程是由进程创建的，是进程的一个实体
-
一个进程可以拥有多个线程
1.4 其他相关概念
-
单线程：同一个时刻只允许执行一个线程
-
多线程：同一个时刻可以执行多个线程，比如：一个qq进程可以同时打开多个聊天窗口，一个迅雷进程，可以同时下载多个文件
-
并发：同一个时刻，多个任务交替执行，造成一种"貌似同时"的错觉，简单地说，单核cpu实现的多任务就是并发。
-
并行：同一个时刻，多个任务同时执行，多核cpu可以实现并行。
-
CPU个数查询
package com.mdklea; public class CpuNum { public static void main(String[] args) { Runtime runtime = Runtime.getRuntime(); int cpuNums = runtime.availableProcessors(); System.out.println("CPU个数：" + cpuNums); } }
2.线程的基本使用
2.1 创建线程的两种方式
在java中，线程使用有两种方法。
-
继承Thread类，重写run方法。
-
实现Runnable接口，重写run方法。
2.2 继承Thread类开启线程
package com.mdklea.threaduse;
public class ThreadUse01 {
public static void main(String[] args) {
//创建Cat对象 可以当作线程使用
Cat cat = new Cat();
/*
（1）
public synchronized void start() {
start0();
}
（2）
//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());
for (int i = 0; i < 30; i++) {
System.out.println("主线程 i = " + i);
try {
Thread.sleep(1000); //让主线程休眠
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
//说明
//当一个类继承了Thread类，该类就可以当作线程使用
//我们会重写run方法，写上自己的业务代码
//run Thread 类实现了Runnable 接口run方法
/*
@Override
public void run() {
if (target != null) {
target.run();
}
}
*/
@SuppressWarnings({"all"})
class Cat extends Thread {
int times = 0;
@Override
public void run() {//重写run方法，写上自己的业务逻辑
while (true){
System.out.println("喵喵，我是小猫咪!" + ++times + " " + Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
if (times == 50){
break; //当times 到50，退出while循环，这时线程也就退出。。
}
}
}
}package com.mdklea.threaduse;
public class ThreadUse01 {
public static void main(String[] args) {
//创建Cat对象 可以当作线程使用
Cat cat = new Cat();
cat.start(); //启动线程
//说明：当main线程启动一个子线程 Thread-0，主线程不会阻塞，会继续执行
//这时，主线程和子线程是交替执行
System.out.println("主线程继续执行" + Thread.currentThread().getName());
for (int i = 0; i < 30; i++) {
System.out.println("主线程 i = " + i);
try {
Thread.sleep(1000); //让主线程休眠
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
//说明
//当一个类继承了Thread类，该类就可以当作线程使用
//我们会重写run方法，写上自己的业务代码
//run Thread 类实现了Runnable 接口run方法
/*
@Override
public void run() {
if (target != null) {
target.run();
}
}
*/
@SuppressWarnings({"all"})
class Cat extends Thread {
int times = 0;
@Override
public void run() {//重写run方法，写上自己的业务逻辑
while (true){
System.out.println("喵喵，我是小猫咪!" + ++times + " " + Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
if (times == 50){
break; //当times 到8，退出while循环，这时线程也就退出。。
}
}
}
}
2.3 实现Runnable接口开启线程
说明
-
java是单继承的，在某些情况下一个类可能已经继承了某个父类，这是再用继承Thread类方法来创建线程显然不可能了。
-
java设计者们提供了另外一个方式创建线程，就是通过实现Runnable接口来创建线程
com.mdklea.threaduse;
public class ThreadUse02 {
public static void main(String[] args) {
// Dog dog = new Dog();
// //dog.start(); 这里不能调用start
// //创建Thread对象，把dog对象(实现Runnable)放入Thread
// //这里使用了设计模式[代理模式]
// Thread thread = new Thread(dog);
// thread.start();
Tiger tiger = new Tiger();
ThreadProxy threadProxy = new ThreadProxy(tiger);
threadProxy.start();
}
}
class Animal{}
class Tiger extends Animal implements Runnable {
@Override
public void run() {
System.out.println("老虎嗷嗷叫");
}
}
//线性代理类，模拟了一个极简的Thread类
class ThreadProxy implements Runnable {//你可以把ThreadProxy(代理)类当作Thread
private Runnable target = null;
@Override
public void run() {
if (target != null){
target.run();
}
}
public ThreadProxy(Runnable target) {
this.target = target;
}
public void start(){
start0();//这个方法是真正实现多线程的方法
}
public void start0() {
run();
}
}
class Dog implements Runnable {//通过实现Runnable接口开发线程
int count = 0;
@Override
public void run() {
while (true){
System.out.println("小狗汪汪叫!" + (++count) + Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
if (count == 10){
break;
}
}
}
}2.4 线程使用的应用案例-多线程执行
请编写一个程序，创建两个线程，一个线程每隔一秒输出hello world ，输出10次，退出，一个线程每隔一秒输出"hi"，输出5次退出。
package com.mdklea.threaduse;
public class ThreadUse03 {
public static void main(String[] args) {
Hello hello = new Hello();
hello.start();
Hi hi = new Hi();
hi.start();
}
}
class Hello extends Thread {
private int count = 0;
@Override
public void run() {
while (true){
System.out.println("hello,world" + (++count) + Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
if (count == 10){
break;
}
}
}
}
class Hi extends Thread {
private int count = 0;
@Override
public void run() {
while (true){
System.out.println("hi" + (++count) + Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
if (count == 5){
break;
}
}
}
}
package com.mdklea.threaduse;
public class ThreadUse03 {
public static void main(String[] args) {
Hello hello = new Hello();
Hi hi = new Hi();
Thread thread1 = new Thread(hello);
Thread thread2 = new Thread(hi);
thread1.start();
thread2.start();
}
}
class Hello implements Runnable {
private int count = 0;
@Override
public void run() {
while (true){
System.out.println("hello,world " + (++count) + Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
if (count == 10){
break;
}
}
}
}
class Hi implements Runnable {
private int count = 0;
@Override
public void run() {
while (true){
System.out.println("hi " + (++count) + Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
if (count == 5){
break;
}
}
}
}2.5 线程如何理解
2.6 继承Thread VS 实现Runnable的区别
-
从java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别，从JDK帮助文档我们可以看到Thread类本身就实现了Runnable接口
-
实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制，建议使用Runnable接口
2.7 售票系统，发现超卖的问题
package com.mdklea.ticket;
public class SellTicket {
/**
*
* 使用多线程模拟三个窗口同时售票100张
*/
public static void main(String[] args) {
// SellTicket01 sellTicket1 = new SellTicket01();
// SellTicket01 sellTicket2 = new SellTicket01();
// SellTicket01 sellTicket3 = new SellTicket01();
// //这里我们会出现超卖。。。
// sellTicket1.start();
// sellTicket2.start();
// sellTicket3.start();
SellTicket02 sellTicket02 = new SellTicket02();
new Thread(sellTicket02).start();
new Thread(sellTicket02).start();
new Thread(sellTicket02).start();
}
}
//使用Thread方式
class SellTicket01 extends Thread {
private static int ticketNum = 100; //让多个线程共享
@Override
public void run() {
while (true){
if (ticketNum <= 0){
System.out.println("售票结束");
break;
}
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口" + Thread.currentThread().getName() + "售出一张票"
+ "剩余票数=" + (--ticketNum));
}
}
}
//实现接口的方式
class SellTicket02 implements Runnable {
private static int ticketNum = 100; //让多个线程共享
@Override
public void run() {
while (true){
if (ticketNum <= 0){
System.out.println("售票结束");
break;
}
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口" + Thread.currentThread().getName() + "售出一张票"
+ "剩余票数=" + (--ticketNum));
}
}
}2.8 线程终止
基本说明
-
当线程完成任务时，会自动退出。
-
还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式
package com.mdklea.exit_;
public class ThreadExit_ {
public static void main(String[] args) {
T t1 = new T();
t1.start();
//如果希望主线程去控制t1线程的终止，必须可以修改loop变量
//让t1退出run方法，从而终止 t1线程 -> 通知方式
//让主线程休眠十秒再通知其退出
try {
Thread.sleep(10 * 1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
t1.setLoop(false);
}
}
class T extends Thread {
int count = 0;
//设置一个控制变量
private boolean loop = true;
@Override
public void run() {
while (loop) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("T 还在运行中" + (++count));
}
}
public void setLoop(boolean loop) {
this.loop = loop;
}
}3.线程常用的方法
3.1 setName
设置线程名称，使之与参数name相同
3.2 getName
返回该线程的名称
3.3 start
使该线程开始执行；java虚拟机底层调用该线程的start0 方法
注意：start底层会创建新的线程，调用run，run就是一个简单的方法调用，不会启动新的线程
3.4 run
调用线程对象的run方法
3.5 setPriority
更改线程的优先级
3.6 getPriority
获取线程的优先级
线程优先级的范围
3.7 sleep
在指定的毫秒内让当前正在执行的线程休眠(暂停执行)
注意：sleep：线程的静态方法，使当前线程休眠
3.8 interrupt
中断线程
注意：interrupt，中断线程，但并没有真正的结束线程。所以一般用于中断正在休眠的线程
package com.mdklea.threadmethods;
public class ThreadMethods_ {
public static void main(String[] args) throws InterruptedException {
//测试相关代码
T t = new T();
t.setName("老马");
t.setPriority(Thread.MIN_PRIORITY);
t.start();
//主线程打印5 hi，然后中断子线程的休眠
for (int i = 0; i < 5; i++) {
Thread.sleep(1000);
System.out.println("hi" + i);
}
System.out.println(t.getName() + "线程优先级=" + t.getPriority());
t.interrupt();//当执行到这里就会中断t线程的休眠
}
}
class T extends Thread { //自定义的线程类
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + " 吃包子" + i);
try {
System.out.println(Thread.currentThread().getName() + " 休眠中");
Thread.sleep(20000);
} catch (InterruptedException e) {
//当该线程执行到一个interrupt方法时，就会catch一个异常，可以加入自己的业务代码
System.out.println(Thread.currentThread().getName() + "被 interrupt了");
}
}
}
}3.9 yield
线程的礼让，让出cpu，让其他线程执行，但礼让的时间不确定，所以也不一定礼让成功
3.10 join
线程的插队
插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务.
案例：创建一个子线程，每隔1s输出hello，输出20次，主线程每隔1s输出hi，输出20次。要求：两个线程同时执行，当主线程输出五次后，就让子线程运行完毕，主线程再继续。
package com.mdklea.threadmethods;
public class ThreadMethods02 {
@SuppressWarnings({"all"})
public static void main(String[] args) throws InterruptedException {
int count = 0;
Hello hello = new Hello();
Thread thread = new Thread(hello);
thread.start();
while (true){
++count;
Thread.sleep(1000);
System.out.println("主线程吃了 " + count + "个包子");
if (count == 5){
System.out.println("主线程(小弟)让子线程先吃");
//thread.yield(); // 没有礼让成功
thread.join();
System.out.println("子线程(老大)吃完了，主线程再接着吃");
}
if (count == 20){
break;
}
}
}
}
@SuppressWarnings({"all"})
class Hello implements Runnable {
private int count = 0;
public int getCount() {
return count;
}
@Override
public void run() {
while (true) {
count++;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("子线程吃了 " + count + "个包子");
if (count == 20){
break;
}
}
}
}3.11 课堂练习
package com.mdklea.threadmethods;
public class ThreadMethodsExercise {
public static void main(String[] args) throws InterruptedException {
Son son = new Son();
Thread thread = new Thread(son);
int count = 0;
for (int i = 0; i < 10; i++) {
count++;
Thread.sleep(1000);
System.out.println("主线程 " + count);
if (count == 5){
System.out.println("主线程让子线程先执行");
thread.start();
thread.join();
System.out.println("子线程执行完毕，主线程继续执行");
}
}
}
}
class Son implements Runnable {
private int count = 0;
@Override
public void run() {
for (int i = 0; i < 10; i++) {
count++;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("子线程 " + count);
}
}
}
3.12 用户线程和守护线程
概念
-
用户线程：也叫工作线程，当线程的任务执行完毕或以通知的方式结束线程
-
守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束
-
常见的守护线程：垃圾回收机制
应用案例
下面我们测试如何将一个线程设置成守护线程
package com.mdklea.threadmethods;
public class ThreadMethods03 {
public static void main(String[] args) throws InterruptedException {
MyDaemonThread myDaemonThread = new MyDaemonThread();
//如果我们希望当main线程结束后，子线程自动结束
//将子线程设置为守护线程即可
myDaemonThread.setDaemon(true);
myDaemonThread.start();
for (int i = 1; i <= 10; i++) {
Thread.sleep(1000);
System.out.println("宝强在辛苦工作");
}
}
}
class MyDaemonThread extends Thread {
@Override
public void run() {
while (true){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("马蓉和宋晶快乐聊天");
}
}
}4.线程的生命周期
4.1 线程的几种状态
JDK中用Thread.State枚举表示了线程的几种状态
5.线程同步机制
5.1 引出线程同步机制
2.7中的超卖问题如何解决呢？
5.2 概念
-
在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多只有一个线程访问，以保证数据的完整性。
-
也可以这样理解：线程同步，即当有一个线程对内存进行操作时，其他线程就不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才对该内存地址进行操作。
5.3 同步具体方法-Synchronized
-
同步代码块
synchronized (对象) { // 得到对象的锁，才能操作同步代码
//需要被同步的代码
}
-
synchronized还可以放在方法声明中，表示整个方法-为同步方法
public synchronized void m(String name){
//需要被同步的代码
}
-
如何理解
就好像 某小伙伴上厕所前先把门关上(上锁)，完事后再出来(解锁)，那么其他小伙伴就可以使用厕所了
5.4 新版售票
package com.mdklea.newticket;
public class SellTicket {
/**
*
* 使用多线程模拟三个窗口同时售票100张
*/
public static void main(String[] args) {
// SellTicket01 sellTicket1 = new SellTicket01();
// SellTicket01 sellTicket2 = new SellTicket01();
// SellTicket01 sellTicket3 = new SellTicket01();
// //这里我们会出现超卖。。。
// sellTicket1.start();
// sellTicket2.start();
// sellTicket3.start();
SellTicket03 sellTicket03 = new SellTicket03();
new Thread(sellTicket03).start();
new Thread(sellTicket03).start();
new Thread(sellTicket03).start();
}
}
class SellTicket03 implements Runnable {
private static int ticketNum = 1000; //让多个线程共享
private boolean loop = true;
@Override
public void run() {
while (loop) {
sell();
}
}
public synchronized void sell() {
if (ticketNum <= 0){
System.out.println("售票结束");
loop = false;
return;
}
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口" + Thread.currentThread().getName() + "售出一张票"
+ "剩余票数=" + (--ticketNum));
}
}
//使用Thread方式
class SellTicket01 extends Thread {
private static int ticketNum = 100; //让多个线程共享
@Override
public void run() {
while (true){
if (ticketNum <= 0){
System.out.println("售票结束");
break;
}
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口" + Thread.currentThread().getName() + "售出一张票"
+ "剩余票数=" + (--ticketNum));
}
}
}
//实现接口的方式
class SellTicket02 implements Runnable {
private static int ticketNum = 100; //让多个线程共享
@Override
public void run() {
while (true){
if (ticketNum <= 0){
System.out.println("售票结束");
break;
}
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口" + Thread.currentThread().getName() + "售出一张票"
+ "剩余票数=" + (--ticketNum));
}
}
}5.5 分析同步原理
6.互斥锁
6.1 基本介绍
-
java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
-
每个对象都对应一个可称为"互斥锁"的标记，这个标记用来保证在任意时刻，只能有一个线程访问该对象。
-
关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任意时刻只能由一个线程访问
-
同步的局限性：导致程序的执行效率要降低
-
同步方法(非静态的)的锁可以是this，也可以是其他对象(要求是同一个对象)
-
同步方法(静态的)的锁为当前类本身
package com.mdklea.newticket;
public class SellTicket {
/**
*
* 使用多线程模拟三个窗口同时售票100张
*/
public static void main(String[] args) {
// SellTicket01 sellTicket1 = new SellTicket01();
// SellTicket01 sellTicket2 = new SellTicket01();
// SellTicket01 sellTicket3 = new SellTicket01();
// //这里我们会出现超卖。。。
// sellTicket1.start();
// sellTicket2.start();
// sellTicket3.start();
SellTicket03 sellTicket03 = new SellTicket03();
new Thread(sellTicket03).start();
new Thread(sellTicket03).start();
new Thread(sellTicket03).start();
}
}
class SellTicket03 implements Runnable {
private static int ticketNum = 100; //让多个线程共享
private boolean loop = true;
@Override
public void run() {
while (loop) {
sell();
}
}
//说明：
//1. public synchronized void sell(){} 就是一个同步方法
//2. 这时锁在 this对象
//3.也可以在代码块上写synchronize，同步代码块，互斥锁还是在this对象
public /*synchronized*/ void sell() {
synchronized (this){
if (ticketNum <= 0) {
System.out.println("售票结束");
loop = false;
return;
}
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口" + Thread.currentThread().getName() + "售出一张票"
+ "剩余票数=" + (--ticketNum));
}
}
//说明：
//1. public synchronized static void m1(){} 锁是加在SellTicket03.class
public synchronized static void m1(){}
//2. 如果在静态方法中，实现一个同步代码块
public static void m2() {
synchronized (SellTicket03.class) {
System.out.println("m2");
}
}
}
//使用Thread方式
class SellTicket01 extends Thread {
private static int ticketNum = 100; //让多个线程共享
@Override
public void run() {
while (true){
if (ticketNum <= 0){
System.out.println("售票结束");
break;
}
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口" + Thread.currentThread().getName() + "售出一张票"
+ "剩余票数=" + (--ticketNum));
}
}
}
//实现接口的方式
class SellTicket02 implements Runnable {
private static int ticketNum = 100; //让多个线程共享
@Override
public void run() {
while (true){
if (ticketNum <= 0){
System.out.println("售票结束");
break;
}
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口" + Thread.currentThread().getName() + "售出一张票"
+ "剩余票数=" + (--ticketNum));
}
}
}6.2 注意事项和细节
-
同步方法如果没有static修饰：默认锁对象为this
-
如果方法使用static修饰，默认锁对象：当前类.class
-
实现的落地步骤：
-
需要先分析上锁的代码
-
选择同步代码块或同步方法
-
要求多个线程的锁对象为同一个即可！
-
7.线程的死锁
7.1 基本介绍
多个线程都占用了对象的锁资源，但不肯相让，导致了死锁，在编程时是一定要避免死锁的发生的
7.2 应用案例
妈妈：你先完成作业，才让你玩手机
小明：你先让我玩手机，我才完成作业
package com.mdklea.deadlock_;
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 Object o2 = new Object();
boolean flag;
public DeadLockDemo(boolean flag) {
this.flag = flag;
}
//下面业务逻辑的分析
//1. 如果flag为T，线程A就会先得到/持有o1对象锁，然后尝试去获取o2对象锁
//2. 如果线程A得不到o2对象锁，就会Blocked
//3. 如果flag为F，线程B就会先得到/持有o2对象锁，然后尝试去获取o1对象锁
//4. 如果线程B得不到o1对象锁，就会Blocked
@Override
public void run() {
if (flag) {
synchronized (o1) {
System.out.println(Thread.currentThread().getName() + " 进入1");
synchronized (o2) {
System.out.println(Thread.currentThread().getName() + " 进入2");
}
}
}else {
synchronized (o2) {
System.out.println(Thread.currentThread().getName() + " 进入3");
synchronized (o1) {
System.out.println(Thread.currentThread().getName() + " 进入4");
}
}
}
}
}8.释放锁
8.1 哪些操作会释放锁？
-
当前线程的同步方法、同步代码块执行结束
案例：上厕所，完事出来
-
当前线程在同步代码块、同步方法中遇到break，return
案例：没有正常完事，经理叫他修改bug，不得不出来
-
当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束
案例：没有正常的完事，发现忘带纸，不得已出来
-
当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。
案例：没有正常完事，觉得需要酝酿下，所以出阿里等会在进去
8.2 哪些操作不会释放锁呢？
-
线程执行同步代码块时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁
案例：上厕所，太困了，在坑位上眯了一会
-
线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁。
提示：应尽量避免使用suspend()和resume()来控制线程，方法不再推荐使用
9.练习题
思路分析
import java.util.Scanner; public class ThreadExercise01 { public static void main(String[] args) { Print print = new Print(); Stop stop = new Stop(print); Thread thread1 = new Thread(print); Thread thread2 = new Thread(stop); thread1.start(); thread2.start(); } } class Print implements Runnable { private boolean loop = true; public boolean isLoop() { return loop; } public void setLoop(boolean loop) { this.loop = loop; } @Override public void run() { //Random r = new Random(); while (loop) { //System.out.println(r.nextInt(101)); try { Thread.sleep(1000); } catch (InterruptedException e) { throw new RuntimeException(e); } System.out.println((int)(Math.random() * 100 + 1)); } System.out.println("print线程退出"); } } class Stop implements Runnable { private Print print; public Stop(Print print) { this.print = print; } @Override public void run() { Scanner sc = new Scanner(System.in); while (true) { System.out.println("请输入\"Q\"结束循环"); String s = sc.next(); if (s.toUpperCase().charAt(0) == 'Q'){ print.setLoop(false); System.out.println("stop线程退出"); break; } } } }
package com.mdklea.threadexercise; public class ThreadExercise02 { public static void main(String[] args) { User user = new User(); Thread user01 = new Thread(user); user01.setName("老马"); Thread user02 = new Thread(user); user02.setName("小明"); Thread user03 = new Thread(user); user03.setName("老于"); user01.start(); user02.start(); user03.start(); } } //因为这里涉及到多个线程共享资源，所以我们使用实现 Runnable方式 class User implements Runnable { private static Object o = new Object(); private static double balance = 1000000; @Override public void run() { while (true) { //解读 //1. 这里使用synchronized 实现了线程同步 //2. 当多个线程执行到这里时，就会去争夺o对象锁 //3. 哪个线程争夺到(获取)该对象锁，就执行synchronized 代码块，执行完后，会释放其对象锁 //4. 争夺不到o对象锁，就blocked，准备继续争夺 //5. 这一对象锁是非公平锁 synchronized (o) { if (balance < 1000) { break; } try { Thread.sleep(100); } catch (InterruptedException e) { throw new RuntimeException(e); } balance -= 1000; System.out.println(Thread.currentThread().getName() + "取出1000，还剩" + balance + "元"); } } } }
扫一扫
503
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
