JavaSE 进阶 - 第24章 多线程（二）
JavaSE 进阶 - 第24章 多线程（二）
- 1、关于线程的调度（了解）
- 2、线程安全问题（重点）——线程同步机制synchronized
- 3、Java中三大变量的线程安全问题
- 4、StringBuffer和StringBuilder的选取
- 5、总结：synchronized的三种写法
- 6、死锁
- 7、在开发中应该怎么解决 线程安全问题？
- 8、守护线程
- 9、定时器
- 10、实现线程的第 3 种方式：实现Callable接口
- 11、关于Object类中的wait和notify方法。（生产者和消费者模式！）
- 传送门
1、关于线程的调度（了解）
1.1、常见的线程调度模型有哪些？
抢占式调度模型：
那个线程的优先级比较高，抢到的CPU时间片的概率就高一些/多一些。
java采用的就是抢占式调度模型！！！
均分式调度模型：
平均分配CPU时间片。每个线程占有的CPU时间片时间长度一样。
平均分配，一切平等。
有一些编程语言，线程调度模型采用的是这种方式。
1.2、与线程调度有关的方法————线程优先级、线程让步、线程合并
注：这几个方法都是线程java.lang.Thread类中
1、线程优先级（实例方法）：
（1）void setPriority(int newPriority) 设置线程的优先级
（2）int getPriority() 获取线程优先级
最低优先级1
默认优先级是5
最高优先级10
优先级比较高的获取CPU时间片可能会多一些。（但也不完全是，大概率是多的。）
每个线程的初始优先级都与创建它的父线程优先级相同。
也就是说，在main方法（主线程）里面new的子线程，初始优先级是和主线程相同的，
（1）如果主线程没有设置优先级，那么子线程的初始优先级和主线程的优先级都是
默认的5，直到子线程的优先级被修改了；
（2）如果一开始就设置了主线程的优先级，比如为1，那么子线程优先级的初始值也会
随之改变，即为1，直到子线程的优先级被修改了。
//了解：关于线程的优先级
public class ThreadTest11 {
public static void main(String[] args) {
//System.out.println("最高优先级" + Thread.MAX_PRIORITY); // 10
//System.out.println("最低优先级" + Thread.MIN_PRIORITY); // 1
//System.out.println("默认优先级" + Thread.NORM_PRIORITY); // 5
// main线程的默认优先级是：5
System.out.println(Thread.currentThread().getName() + "线程的默认优先级是：" + Thread.currentThread().getPriority()); //5
// 设置主线程的优先级为1
Thread.currentThread().setPriority(1);
System.out.println(Thread.currentThread().getName() + "线程的优先级是：" + Thread.currentThread().getPriority()); //1
//子线程t
Thread t = new Thread(new MyRunnable5());
t.setName("t");
System.out.println(t.getName() + "线程的默认优先级是：" + t.getPriority()); //1(同主线程)
// 设置子线程的优先级为10
t.setPriority(10);
System.out.println(t.getName() + "线程的优先级是：" + t.getPriority()); //10
t.start();
// 优先级较高的，只是抢到的CPU时间片相对多一些。
// 大概率方向更偏向于优先级比较高的。
for(int i = 0; i < 10000; i++){
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}
class MyRunnable5 implements Runnable {
@Override
public void run() {
for(int i = 0; i < 10000; i++){
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}
2、线程让步（静态方法）：
static void yield() 线程让位
调用：Thread.yield();
暂停当前正在执行的线程对象，并执行其他线程
yield()方法不是阻塞方法。让当前线程让位，让给其它线程使用。
yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”。
注意：在回到就绪之后，有可能还会再次抢到。
/*
让位，当前线程暂停，回到就绪状态，让给其它线程。
静态方法：Thread.yield();
*/
public class ThreadTest12 {
public static void main(String[] args) {
Thread t = new Thread(new MyRunnable6());
t.setName("t");
t.start();
for(int i = 1; i <= 10000; i++) {
System.out.println(Thread.currentThread().getName() + "--->" + i);
}
}
}
class MyRunnable6 implements Runnable {
@Override
public void run() {
for(int i = 1; i <= 10000; i++) {
//每100个让位一次。
if(i % 100 == 0){
Thread.yield(); // 当前线程暂停一下，让给主线程。
}
System.out.println(Thread.currentThread().getName() + "--->" + i);
}
}
}
3、线程合并（实例方法）：
void join() 线程合并
class MyThread1 extends Thread {
public void doSome(){
MyThread2 t = new MyThread2();
t.join(); // 当前线程(MyThread1)进入阻塞，让t线程(MyThread2)执行，直到t线程结束，当前线程才可以继续。
}
}
class MyThread2 extends Thread{
}
/*
线程合并
*/
public class ThreadTest13 {
public static void main(String[] args) {
System.out.println("main begin");
Thread t = new Thread(new MyRunnable7());
t.setName("t");
t.start();
//合并线程
try {
t.join(); // t合并到当前线程中，当前线程受阻塞，t线程执行直到结束。
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("main over");
}
}
class MyRunnable7 implements Runnable {
@Override
public void run() {
for(int i = 0; i < 10000; i++){
System.out.println(Thread.currentThread().getName() + "--->" + i);
}
}
}
/*
main begin
t--->0
t--->1
t--->2
t--->3
t--->4
...
t--->9999
main over
*/
2、线程安全问题（重点）——线程同步机制synchronized
2.1、为什么这个是重点？
以后在开发中，我们的项目都是运行在服务器当中，而服务器已经将
线程的定义、线程对象的创建、线程的启动等，都已经实现完了。
这些代码我们都不需要编写。
最重要的是：
你要知道，你编写的程序需要放到一个多线程的环境下运行，
你更需要关注的是这些数据在多线程并发的环境下是否是安全的。（重点：*****）
2.2、线程不安全的3个条件
什么时候数据在多线程并发的环境下会存在安全问题呢？
三个条件：
条件1：多线程并发。
条件2：有共享数据。
条件3：共享数据有修改的行为。
满足以上3个条件之后，就会存在线程安全问题。
举例：【005-多线程并发对同一个账户进行取款】
2.3、怎么解决线程安全问题？————线程同步机制
当多线程并发的环境下，有共享数据，并且这个数据还会被修改，此时就存在
线程安全问题，怎么解决这个问题？
线程排队执行。（不能并发）。
用排队执行解决线程安全问题。
这种机制被称为：线程同步机制。
专业术语叫做：线程同步，实际上就是线程不能并发了，线程必须排队执行。
线程同步就是线程排队了，线程排队了就会牺牲一部分效率，没办法，数据安全第一位，
只有数据安全了，我们才可以谈效率。数据不安全，没有效率的事儿。
2.4、关于同步和异步
异步编程模型：
线程t1和线程t2，各自执行各自的，t1不管t2，t2不管t1，
谁也不需要等谁，这种编程模型叫做：异步编程模型。
其实就是：多线程并发（效率较高。）
异步就是并发。
同步编程模型：
线程t1和线程t2，在线程t1执行的时候，必须等待t2线程执行结束，
或者说在t2线程执行的时候，必须等待t1线程执行结束，
两个线程之间发生了等待关系，这就是同步编程模型。
线程排队执行。（效率较低）
同步就是排队。
2.5 【实例2-1】： 模拟银行账户取款
编写程序模拟 2 个线程同时对 1 个账户进行取款操作。
不使用线程同步机制，多线程对同一个账户进行取款，会出现线程安全问题。
【threadsafe/Account.java + AccountThread.java + Test.java】
/*
银行账户
不使用线程同步机制，多线程对同一个账户进行取款，出现线程安全问题。
*/
public class Account {
// 账号
private String actno;
// 余额
private double balance;
public Account() {
}
public Account(String actno, double balance) {
this.actno = actno;
this.balance = balance;
}
public String getActno() {
return actno;
}
public void setActno(String actno) {
this.actno = actno;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
//取款的方法
public void withdraw(double money){
// t1和t2并发这个方法。。。。（t1和t2是两个栈。两个栈操作堆中同一个对象。）
// 1、取款之前的余额
double before = this.getBalance(); // 10000
// 2、取款之后的余额
double after = before - money;
// 在这里模拟一下网络延迟，100%会出现问题
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 3、更新余额
// 思考：t1执行到这里了，但还没有来得及执行这行代码，t2线程也进来这个方法了。此时一定出问题。
this.setBalance(after);
}
}
public class AccountThread extends Thread {
// 两个线程必须共享同一个账户对象。
private Account act;
// 通过构造方法传递过来账户对象
public AccountThread(Account act) {
this.act = act;
}
public void run(){
// run方法的执行表示取款操作。
// 假设取款5000
double money = 5000;
// 取款
// 多线程并发执行这个方法:
act.withdraw(money);
System.out.println(Thread.currentThread().getName() + "对"+act.getActno()+"取款"+money+"成功，余额" + act.getBalance());
}
}
public class Test {
public static void main(String[] args) {
// 创建账户对象（只创建1个）
Account act = new Account("act-001", 10000);//存进去1万
// 创建两个线程
Thread t1 = new AccountThread(act);
Thread t2 = new AccountThread(act);
// 设置name
t1.setName("t1");
t2.setName("t2");
// 启动线程取款
t1.start();
t2.start();
}
}
/*第一次结果：（果然出问题了，取了两个5000结果余额还有5000）
t1对act-001取款5000.0成功，余额5000.0
t2对act-001取款5000.0成功，余额5000.0
*/
2.6 线程同步机制synchronized
线程同步机制的语法是：
synchronized(){
// 线程同步代码块。
}
synchronized后面小括号中传的这个“数据”是相当关键的。
这个数据必须是多线程共享的数据。才能达到多线程排队。
()中写什么？
那要看你想让哪些线程同步。
假设t1、t2、t3、t4、t5，有5个线程，
你只希望t1 t2 t3排队，t4 t5不需要排队。怎么办？
你一定要在()中写一个t1 t2 t3共享的对象。而这个
对象对于t4 t5来说不是共享的。
在java语言中，任何一个对象都有“一把锁”，其实这把锁就是标记。（只是把它叫做锁。）
100个对象，100把锁。1个对象1把锁。
线程同步机制执行原理：
1、假设t1和t2线程并发，开始执行相关代码的时候，肯定有一个先一个后。
2、假设t1先执行了，遇到了synchronized，这个时候自动找“后面共享对象”的对象锁，
找到之后，并占有这把锁，然后执行同步代码块中的程序，在程序执行过程中一直都是
占有这把锁的。直到同步代码块代码结束，这把锁才会释放。
3、假设t1已经占有这把锁，此时t2也遇到synchronized关键字，也会去占有后面
共享对象的这把锁，结果这把锁被t1占有，t2只能在同步代码块外面等待t1的结束，
直到t1把同步代码块执行结束了，t1会归还这把锁，此时t2终于等到这把锁，然后
t2占有这把锁之后，进入同步代码块执行程序。
这样就达到了线程排队执行。
注意：这个共享对象一定要选好了。
这个共享对象一定是你需要排队执行的这些线程对象所共享的。
【实例2-2】使用线程同步机制，解决线程安全问题。
【threadsafe2/Account.java + AccountThread.java + Test.java】
public class Account {
// 账号
private String actno;
// 余额
private double balance;
public Account() {
}
public Account(String actno, double balance) {
this.actno = actno;
this.balance = balance;
}
public String getActno() {
return actno;
}
public void setActno(String actno) {
this.actno = actno;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
//取款的方法
public void withdraw(double money){
// 以下这几行代码必须是线程排队的，不能并发。
// 一个线程把这里的代码全部执行结束之后，另一个线程才能进来。
/*
线程同步机制：
这里的共享对象是：账户对象。
账户对象是共享的，那么this就是账户对象吧！！！
不一定是this，这里只要是多线程共享的那个对象就行。
*/
//synchronized (this){ //可以 ，this就是当前对象：Account对象。Account对象是多线程共享的
//synchronized ("abc") { //可以，"abc"在字符串常量池当中，也是共享的，不过这样的话所有线程都是同步的
//Object obj2 = new Object();
//synchronized (obj2) { // 这样编写就不安全了。因为obj2不是共享对象。
double before = this.getBalance();
double after = before - money;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setBalance(after);
//}
}
}
//注：最终threadsafe2包下面这个Account类和上面threadsafe包里面的Account一样，还是没有变，
//变的是AccountThread类，添加了synchronized
public class AccountThread extends Thread {
// 两个线程必须共享同一个账户对象。
private Account act;
// 通过构造方法传递过来账户对象
public AccountThread(Account act) {
this.act = act;
}
public void run(){
// run方法的执行表示取款操作。
// 假设取款5000
double money = 5000;
// 取款
// 多线程并发执行这个方法:
synchronized (act) { // 这种方式也可以，只不过扩大了同步的范围（相比较synchronized放在Account类中来说），效率更低了
act.withdraw(money);
}
System.out.println(Thread.currentThread().getName() + "对"+act.getActno()+"取款"+money+"成功，余额" + act.getBalance());
}
}
//注：这个类变了，run方法里面调用取款方法 act.withdraw(money)时，添加了synchronized线程同步机制
public class Test {
public static void main(String[] args) {
// 创建账户对象（只创建1个）
Account act = new Account("act-001", 10000);
// 创建两个线程
Thread t1 = new AccountThread(act);
Thread t2 = new AccountThread(act);
// 设置name
t1.setName("t1");
t2.setName("t2");
// 启动线程取款
t1.start();
t2.start();
}
}
/*第二次结果：（这次没问题了）
t1对act-001取款5000.0成功，余额5000.0
t2对act-001取款5000.0成功，余额0.0
*/
【实例2-3】也可以直接在实例方法上可以使用synchronized
【threadsafe3/Account.java + AccountThread.java + Test.java】
public class Account {
// 账号
private String actno;
// 余额
private double balance;
public Account() {
}
public Account(String actno, double balance) {
this.actno = actno;
this.balance = balance;
}
public String getActno() {
return actno;
}
public void setActno(String actno) {
this.actno = actno;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
//取款的方法
/*
在实例方法上可以使用synchronized吗？
可以的。
synchronized出现在实例方法上，一定锁的是this。
只能是this，不能是其他的对象了。
所以这种方式不灵活。
另外还有一个缺点：synchronized出现在实例方法上，
表示整个方法体都需要同步，可能会无故扩大同步的范围，
导致程序的执行效率降低。所以这种方式不常用。
synchronized使用在实例方法上有什么优点？
代码写的少了。节俭了。
如果共享的对象就是this，并且需要同步的代码块是整个方法体，
建议使用这种方式。
*/
public synchronized void withdraw(double money){
double before = this.getBalance(); // 10000
double after = before - money;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setBalance(after);
}
}
//注：相比较上面threadsafe包里面的Account类
//threadsafe3包下面这个Account类修改之处为：
//在取款方法withdraw的返回值类型void前面添加了 synchronized
public class AccountThread extends Thread {
// 两个线程必须共享同一个账户对象。
private Account act;
// 通过构造方法传递过来账户对象
public AccountThread(Account act) {
this.act = act;
}
public void run(){
// run方法的执行表示取款操作。
// 假设取款5000
double money = 5000;
// 取款
// 多线程并发执行这个方法：
act.withdraw(money);
System.out.println(Thread.currentThread().getName() + "对"+act.getActno()+"取款"+money+"成功，余额" + act.getBalance());
}
}
public class Test {
public static void main(String[] args) {
// 创建账户对象（只创建1个）
Account act = new Account("act-001", 10000);
// 创建两个线程
Thread t1 = new AccountThread(act);
Thread t2 = new AccountThread(act);
// 设置name
t1.setName("t1");
t2.setName("t2");
// 启动线程取款
t1.start();
t2.start();
}
}
/*第三次结果：（这次也没问题）
t1对act-001取款5000.0成功，余额5000.0
t2对act-001取款5000.0成功，余额0.0
*/
3、Java中三大变量的线程安全问题
局部变量：在栈中。
实例变量：在堆中。
静态变量：在方法区。
以上三大变量中：
局部变量永远都不会存在线程安全问题。
因为局部变量不共享。（一个线程一个栈。）
局部变量在栈中。所以局部变量永远都不会共享。
实例变量在堆中，堆只有1个。
静态变量在方法区中，方法区只有1个。
堆和方法区都是多线程共享的，所以可能存在线程安全问题。
局部变量+常量：不会有线程安全问题。
成员变量（实例变量和静态变量）：可能会有线程安全问题。
4、StringBuffer和StringBuilder的选取
【回顾第20章：常用类】java.lang下面用于处理字符串常用的三个类:
String————不可变字符序列
StringBuffer————可变字符序列、线程安全、效率低（速度慢）
StrungBuilder————可变字符序列、线程不安全、效率高（速度快）
String的值是不可变的，每次对String的操作都会生成新的String对象；
当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。
StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。
StringBuilder 和 StringBuffer 的区别是：
StringBuffer 中所有的方法都是同步的，StringBuffer中的几乎所有方法都有：synchronized关键字修饰，是线程安全的，但速度慢，
StringBuilder 的速度快，但不是线程安全的
如果使用局部变量的话：
建议使用：StringBuilder。因为局部变量不存在线程安全问题。
StringBuffer是线程安全的，但效率比较低。
StringBuilder不是线程安全的，但效率高。
另外：
ArrayList是非线程安全的。
Vector是线程安全的。
HashMap HashSet是非线程安全的。
Hashtable是线程安全的。
5、总结：synchronized的三种写法
第一种：同步代码块
灵活
synchronized(线程共享对象){
同步代码块;
}
第二种：在实例方法上使用synchronized
表示找对象锁。
1个对象1把锁。
表示共享对象一定是this
并且同步代码块是整个方法体。
第三种：在静态方法上使用synchronized
表示找类锁。（静态方法不需要new对象，直接调用：类名.方法名）
类锁永远只有1把。
就算创建了100个对象，那类锁也只有一把。
对象锁：1个对象1把锁，100个对象100把锁。
类锁：100个对象，也可能只是1把类锁。
【exam1/Exam01.java】【exam2/Exam01.java】【exam3/Exam01.java】【exam4/Exam01.java】
package com.yuming.java.exam1;
// 面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
//不需要，因为doOther()方法没有synchronized
public class Exam01 {
public static void main(String[] args) throws InterruptedException {
MyClass mc = new MyClass();
Thread t1 = new MyThread(mc);
Thread t2 = new MyThread(mc);
t1.setName("t1");
t2.setName("t2");
t1.start();
Thread.sleep(1000); //这个睡眠的作用是：为了保证t1线程先执行。
t2.start();
}
}
class MyThread extends Thread {
private MyClass mc;
public MyThread(MyClass mc){
this.mc = mc;
}
public void run(){
if(Thread.currentThread().getName().equals("t1")){
mc.doSome();
}
if(Thread.currentThread().getName().equals("t2")){
mc.doOther();
}
}
}
class MyClass {
public synchronized void doSome(){ //-----------------------方法名上有synchronized
System.out.println("doSome begin");
try {
Thread.sleep(1000 * 10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("doSome over");
}
public void doOther(){
System.out.println("doOther begin");
System.out.println("doOther over");
}
}
/*
doSome begin
doOther begin
doOther over
doSome over
*/
package com.yuming.java.exam2;
// 面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
//需要
public class Exam01 {
public static void main(String[] args) throws InterruptedException {
MyClass mc = new MyClass();
Thread t1 = new MyThread(mc);
Thread t2 = new MyThread(mc);
t1.setName("t1");
t2.setName("t2");
t1.start();
Thread.sleep(1000); //这个睡眠的作用是：为了保证t1线程先执行。
t2.start();
}
}
class MyThread extends Thread {
private MyClass mc;
public MyThread(MyClass mc){
this.mc = mc;
}
public void run(){
if(Thread.currentThread().getName().equals("t1")){
mc.doSome();
}
if(Thread.currentThread().getName().equals("t2")){
mc.doOther();
}
}
}
class MyClass {
public synchronized void doSome(){ //-----------------------方法名上有synchronized
System.out.println("doSome begin");
try {
Thread.sleep(1000 * 10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("doSome over");
}
public synchronized void doOther(){ //-----------------------方法名上有synchronized
System.out.println("doOther begin");
System.out.println("doOther over");
}
}
/*
doSome begin
doSome over //dosome结束之后，doother才开始
doOther begin
doOther over
*/
package com.yuming.java.exam3;
// 面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
//不需要，因为MyClass对象是两个，两把锁。
public class Exam01 {
public static void main(String[] args) throws InterruptedException {
MyClass mc1 = new MyClass();
MyClass mc2 = new MyClass();
Thread t1 = new MyThread(mc1);
Thread t2 = new MyThread(mc2);
t1.setName("t1");
t2.setName("t2");
t1.start();
Thread.sleep(1000); //这个睡眠的作用是：为了保证t1线程先执行。
t2.start();
}
}
class MyThread extends Thread {
private MyClass mc;
public MyThread(MyClass mc){
this.mc = mc;
}
public void run(){
if(Thread.currentThread().getName().equals("t1")){
mc.doSome();
}
if(Thread.currentThread().getName().equals("t2")){
mc.doOther();
}
}
}
class MyClass {
public synchronized void doSome(){ //---------------------方法名上有synchronized
System.out.println("doSome begin");
try {
Thread.sleep(1000 * 10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("doSome over");
}
public synchronized void doOther(){ //---------------------方法名上有synchronized
System.out.println("doOther begin");
System.out.println("doOther over");
}
}
/*
doSome begin
doOther begin
doOther over
doSome over
*/
package com.yuming.java.exam4;
// 面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
//需要，因为静态方法是类锁，不管创建了几个对象，类锁只有1把。
public class Exam01 {
public static void main(String[] args) throws InterruptedException {
MyClass mc1 = new MyClass();
MyClass mc2 = new MyClass();
Thread t1 = new MyThread(mc1);
Thread t2 = new MyThread(mc2);
t1.setName("t1");
t2.setName("t2");
t1.start();
Thread.sleep(1000); //这个睡眠的作用是：为了保证t1线程先执行。
t2.start();
}
}
class MyThread extends Thread {
private MyClass mc;
public MyThread(MyClass mc){
this.mc = mc;
}
public void run(){
if(Thread.currentThread().getName().equals("t1")){
mc.doSome();
}
if(Thread.currentThread().getName().equals("t2")){
mc.doOther();
}
}
}
class MyClass {
// synchronized出现在静态方法上是找类锁。
public synchronized static void doSome(){//--------静态方法-------------方法名上有synchronized
System.out.println("doSome begin");
try {
Thread.sleep(1000 * 10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("doSome over");
}
public synchronized static void doOther(){//-------静态方法--------------方法名上有synchronized
System.out.println("doOther begin");
System.out.println("doOther over");
}
}
/*
doSome begin
doSome over //dosome结束之后，doother才开始
doOther begin
doOther over
*/
6、死锁
什么是死锁？
所谓死锁，是指多个进程在运行过程中因争夺资源而造成的一种僵局，
当进程处于这种僵持状态时，若无外力作用，它们都将无法再向前推进。
举个例子来描述：
如果此时有一个线程T1，按照先锁对象a再锁对象b的的顺序运行，
而在此同时又有另外一个线程T2，按照先锁对象b再锁对象a的顺序运行。
如下图所示：
/*
死锁代码要会写。
一般面试官要求你会写。
只有会写的，才会在以后的开发中注意这个事儿。
因为死锁很难调试。
*/
public class DeadLock {
public static void main(String[] args) {
Object o1 = new Object();
Object o2 = new Object();
// t1和t2两个线程共享o1,o2
Thread t1 = new MyThread1(o1,o2);
Thread t2 = new MyThread2(o1,o2);
t1.start();
t2.start();
}
}
class MyThread1 extends Thread{
Object o1;
Object o2;
public MyThread1(Object o1,Object o2){
this.o1 = o1;
this.o2 = o2;
}
public void run(){
synchronized (o1){ //先锁o1，
try {
Thread.sleep(1000); //睡1秒
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (o2){ //再锁o2
}
}
}
}
class MyThread2 extends Thread {
Object o1;
Object o2;
public MyThread2(Object o1,Object o2){
this.o1 = o1;
this.o2 = o2;
}
public void run(){
synchronized (o2){//先锁o2
try {
Thread.sleep(1000);//睡1秒
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (o1){ //再锁o1
}
}
}
}
注意：synchronized在开发中最好不要嵌套使用，一不小心就可能导致死锁现象的发生！
7、在开发中应该怎么解决 线程安全问题？
是一上来就选择线程同步吗？synchronized
不是，synchronized会让程序的执行效率降低，用户体验不好。
系统的用户吞吐量降低。在不得已的情况下再选择线程同步机制。
第一种方案：尽量使用局部变量代替“实例变量和静态变量”。
第二种方案：如果必须是实例变量，那么可以考虑创建多个对象，这样实例变量的内存就不共享了。
（一个线程对应1个对象，100个线程对应100个对象，对象不共享，就没有数据安全问题了。）
第三种方案：如果不能使用局部变量，对象也不能创建多个，这个时候就只能选择synchronized了。
线程同步机制。
8、守护线程
java语言中线程分为两大类：
一类是：用户线程
一类是：守护线程（后台线程）
其中具有代表性的就是：垃圾回收线程（守护线程）。
守护线程的特点：
一般守护线程是一个死循环，
所有的用户线程只要结束，守护线程自动结束。
注意：主线程main方法是一个用户线程。
守护线程用在什么地方呢？
每天00:00的时候系统数据自动备份。
这个需要使用到定时器，并且我们可以将定时器设置为守护线程。
一直在那里看着，每到00:00的时候就备份一次。
所有的用户线程如果结束了，守护线程自动退出，没有必要进行数据备份了。
实现守护线程的方法：void setDaemon(boolean on)
启动线程t.start()之前，将线程设置为守护线程t.setDaemon(true);
/*
守护线程
*/
public class ThreadTest14 {
public static void main(String[] args) {
Thread t = new BakDataThread();
t.setName("备份数据的线程");
// 启动线程之前，将线程设置为守护线程
t.setDaemon(true);
t.start();
// 主线程：主线程是用户线程
for(int i = 0; i < 10; i++){ //每打印一行，等待一秒，打印10行
System.out.println(Thread.currentThread().getName() + "--->" + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class BakDataThread extends Thread {
public void run(){
int i = 0;
// 即使是死循环，但由于该线程是守护者，当用户线程结束，守护线程自动终止。
while(true){//每打印一行，等待一秒，一直打印
System.out.println(Thread.currentThread().getName() + "--->" + (++i));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
/*
main--->0
备份数据的线程--->1
main--->1
备份数据的线程--->2
备份数据的线程--->3
main--->2
main--->3
备份数据的线程--->4
main--->4
备份数据的线程--->5
main--->5
备份数据的线程--->6
main--->6
备份数据的线程--->7
备份数据的线程--->8
main--->7
备份数据的线程--->9
main--->8
main--->9
备份数据的线程--->10
备份数据的线程--->11
*/
9、定时器
定时器的作用：
间隔特定的时间，执行特定的程序。
例如：每周要进行银行账户的总账操作...
每天要进行数据的备份操作...
...
在实际的开发中，每隔多久执行一段特定的程序，这种需求是很常见的，
有多种方式实现：
（1）可以使用sleep方法，睡眠，设置睡眠时间，每到这个时间点醒来，执行任务。
这种方式是最原始的定时器。（比较low）
（2）在java的类库中已经写好了一个定时器：java.util.Timer，可以直接拿来用。
不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持定时任务的。
（3）在实际的开发中，目前使用较多的是Spring框架中提供的SpringTask框架，
这个框架只要进行简单的配置，就可以完成定时器的任务。
实现定时器（第二种方法）：
// 创建定时器对象
Timer timer = new Timer();
// 指定定时任务
timer.schedule(定时任务, 第一次执行时间, 间隔多久执行一次);
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
//使用定时器指定定时任务。
public class TimerTest {
public static void main(String[] args) throws Exception {
// 创建定时器对象
Timer timer = new Timer();
//Timer timer = new Timer(true); //守护线程的方式
// 指定定时任务
//timer.schedule(定时任务, 第一次执行时间, 间隔多久执行一次);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date firstTime = sdf.parse("2020-07-21 19:26:20");
timer.schedule(new LogTimerTask() , firstTime, 1000 * 3); // 每3秒执行一次。
/*//也可匿名内部类方式
timer.schedule(new TimerTask(){
@Override
public void run() {
// code....（代码直接复制下面LogTimerTask类中run方法的）
}
} , firstTime, 1000 * 3);*/
}
}
// 编写一个定时任务类
// 假设这是一个记录日志的定时任务，继承自java.util.TimerTask
class LogTimerTask extends TimerTask {
@Override
public void run() {
// 编写你需要执行的任务就行了。
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String strTime = sdf.format(new Date());//new Date()获取当前时间
System.out.println(strTime + ":成功完成了一次数据备份！");
}
}
10、实现线程的第 3 种方式：实现Callable接口
实现线程的第 3 种方式：实现Callable接口。（JDK8新特性。）
这种方式实现的线程可以获取线程的返回值。
之前讲解的那两种方式是无法获取线程返回值的，因为run方法返回void。
思考：
系统委派一个线程去执行一个任务，该线程执行完任务之后，可能
会有一个执行结果，我们怎么能拿到这个执行结果呢？
使用第三种方式：实现Callable接口方式。
优点：可以获取到线程的执行结果。
缺点：效率比较低，在获取该线程执行结果的时候，当前线程受阻塞，效率较低。
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask; // JUC包下的，属于java的并发包，老JDK中没有这个包。新特性。
public class ThreadTest15 {
public static void main(String[] args) throws Exception {
// 第一步：创建一个“未来任务类”对象。
// 参数非常重要，需要给一个Callable接口实现类对象。
FutureTask task = new FutureTask(new Callable() { //匿名内部类
@Override
public Object call() throws Exception { // call()方法就相当于run方法。只不过这个有返回值
// 线程执行一个任务，执行之后可能会有一个执行结果
// 模拟执行
System.out.println("call method begin");
Thread.sleep(1000 * 10);
System.out.println("call method end!");
int a = 100;
int b = 200;
return a + b; //自动装箱(300结果变成Integer)
}
});
// 创建线程对象
Thread t = new Thread(task);
// 启动线程
t.start();
// 这里是main方法，这是在主线程中。
// 在主线程中，怎么获取t线程的返回结果？
// get()方法的执行会导致“当前线程阻塞”
Object obj = task.get();
System.out.println("线程执行结果:" + obj);
// main方法这里的程序要想执行必须等待get()方法的结束
// 而get()方法可能需要很久。因为get()方法是为了拿另一个线程的执行结果
// 另一个线程执行是需要时间的。
System.out.println("hello world!");
}
}
/*
call method begin
call method end! （过了10秒才输出后面的）
线程执行结果:300
hello world!
*/
11、关于Object类中的wait和notify方法。（生产者和消费者模式！）
1、wait和notify方法不是线程对象的方法，是java中任何一个java对象
都有的方法，因为这两个方式是Object类中自带的。
2、wait()方法作用？
Object o = new Object();
o.wait();
表示：
让正在o对象上活动的线程进入等待状态，无期限等待，直到被唤醒为止。
o.wait();方法的调用，会让“当前线程（正在o对象上活动的线程）”进入等待状态。
3、notify()方法作用？
Object o = new Object();
o.notify();
表示：
唤醒正在o对象上等待的线程。
还有一个notifyAll()方法：
这个方法是唤醒o对象上处于等待的所有线程。
4、生产者和消费者模式
4.1、使用wait方法和notify方法实现“生产者和消费者模式”
4.2、什么是“生产者和消费者模式”？
生产线程负责生产，消费线程负责消费。
生产线程和消费线程要达到均衡。
这是一种特殊的业务需求，在这种特殊的情况下需要使用wait方法和notify方法。
4.3、wait和notify方法不是线程对象的方法，是普通java对象都有的方法。
4.4、wait方法和notify方法建立在线程同步的基础之上。因为多线程要同时操作一个仓库。有线程安全问题。
4.5、wait方法作用：o.wait()让正在o对象上活动的线程t进入等待状态，并且释放掉t线程之前占有的o对象的锁。
4.6、notify方法作用：o.notify()让正在o对象上等待的线程唤醒，只是通知，不会释放o对象上之前占有的锁。
import java.util.ArrayList;
import java.util.List;
/*
使用wait方法和notify方法实现“生产者和消费者模式”
【实例】模拟这样一个需求：
仓库我们采用List集合。
List集合中假设只能存储1个元素。
1个元素就表示仓库满了。
如果List集合中元素个数是0，就表示仓库空了。
保证List集合中永远都是最多存储1个元素。
必须做到这种效果：生产1个消费1个。
*/
public class ThreadTest16 {
public static void main(String[] args) {
// 创建1个仓库对象，共享的。
List list = new ArrayList();
// 创建两个线程对象
// 生产者线程
Thread t1 = new Thread(new Producer(list));
// 消费者线程
Thread t2 = new Thread(new Consumer(list));
t1.setName("生产者线程");
t2.setName("消费者线程");
t1.start();
t2.start();
}
}
// 生产线程
class Producer implements Runnable {
// 仓库
private List list;
public Producer(List list) {
this.list = list;
}
@Override
public void run() {
// 一直生产（使用死循环来模拟一直生产）
while(true){
// 给仓库对象list加锁。
synchronized (list){
if(list.size() > 0){ // 大于0，说明仓库中已经有1个元素了。
try {
// 当前线程进入等待状态，并且释放Producer之前占有的list集合的锁。
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 程序能够执行到这里说明仓库是空的，可以生产
Object obj = new Object();
list.add(obj);
System.out.println(Thread.currentThread().getName() + "--->" + obj);
// 唤醒消费者进行消费
list.notify();
//list.notifyAll();//也可以
}
}
}
}
// 消费线程
class Consumer implements Runnable {
// 仓库
private List list;
public Consumer(List list) {
this.list = list;
}
@Override
public void run() {
// 一直消费
while(true){
synchronized (list) {
if(list.size() == 0){
try {
// 仓库已经空了。
// 消费者线程等待，释放掉list集合的锁
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 程序能够执行到此处说明仓库中有数据，进行消费。
Object obj = list.remove(0);
System.out.println(Thread.currentThread().getName() + "--->" + obj);
// 唤醒生产者生产。
list.notify();
//list.notifyAll();//也可以
}
}
}
}
/*
生产者线程--->java.lang.Object@6a930845
消费者线程--->java.lang.Object@6a930845
生产者线程--->java.lang.Object@7e6b9181
消费者线程--->java.lang.Object@7e6b9181
生产者线程--->java.lang.Object@2898991b
消费者线程--->java.lang.Object@2898991b
.....(一直运行)
*/
传送门
上一章：JavaSE 进阶 - 第24章 多线程（一）
下一章：JavaSE 进阶 - 第25章 反射机制