多线程
一、多线程概述
-
进程与线程
进程是一个应用程序（1个进程是一个软件）。
线程是一个进程中的执行场景/执行单元。
一个进程可以启动多个线程。 -
对于java程序来说，当在DOS命令窗口中输入：java HelloWorld 回车之后。会先启动JVM，而JVM就是一个进程。JVM再启动一个主线程调用main方法。同时再启动一个垃圾回收线程负责看护，回收垃圾。最起码，现在的java程序中至少有两个线程并发，一个是垃圾回收线程，一个是执行main方法的主线程。
-
进程和线程的关系
进程可以看做是现实生活当中的公司。
线程可以看做是公司当中的某个员工。注意：
（1）进程A和进程B的内存独立不共享。
英雄联盟是一个进程
网易云音乐是一个进程
这两个进程是独立的，不共享资源。（2）线程A和线程B在java语言中：
线程A和线程B，堆内存和方法区内存共享。
但是栈内存独立，一个线程一个栈。 假设启动10个线程，会有10个栈空间，每个栈和每个栈之间，互不干扰，各自执行各自的，这就是多线程并发。
java中之所以有多线程机制，目的就是为了提高程序的处理效率。
-
使用了多线程机制之后，main方法结束只是主线程结束，主栈空，其它的栈(线程)可能还在压栈弹栈。
-
分析一个问题：对于单核的CPU来说，真的可以做到真正的多线程并发吗？
对于多核的CPU电脑来说，真正的多线程并发是没问题的。4核CPU表示同一个时间点上，可以真正的有4个进程并发执行。
什么是真正的多线程并发？
t1线程执行t1的。
t2线程执行t2的。
t1不会影响t2，t2也不会影响t1。这叫做真正的多线程并发。单核的CPU表示只有一个大脑：
不能够做到真正的多线程并发，但是可以做到给人一种“多线程并发”的感觉。对于单核的CPU来说，在某一个时间点上实际上 只能处理一件事情，但是由于CPU的处理速度极快，多个线程之间频繁切换执行，跟人来的感觉是：多个事情同时在做！ -
java语言中，实现线程有两种方式。
java支持多线程机制。并且java已经将多线程实现了，我们只需要继承就行了。
第一种方式：编写一个类，直接继承java.lang.Thread，重写run方法。
// 定义线程类 public class MyThread extends Thread{ public void run(){ } } // 创建线程对象 MyThread t = new MyThread(); // 启动线程。 t.start();package Thread; public class ThreadTest01 { public static void main(String[] args) { MyThread myThread = new MyThread(); //启动线程 myThread.start(); for(int i = 0;i < 1000;i++){ System.out.println("main线程--->" + i); } } } class MyThread extends Thread{ @Override public void run() { for(int i = 0;i < 1000;i++){ System.out.println("分支线程--->" + i); } } }**注意：**start（）方法的作用是：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码完成任务后瞬间结束。启动成功的线程会自动调用run（）方法，并且run方法在分支栈的栈底部（压栈），main方法在主栈的底部，run（）方法和main方法是平级的。
第二种方式：编写一个类，实现java.lang.Runnable接口，实现run方法。
// 定义一个可运行的类 public class MyRunnable implements Runnable { public void run(){ } } // 创建线程对象 Thread t = new Thread(new MyRunnable()); // 启动线程 t.start();package Thread; public class ThreadTest02 { public static void main(String[] args) { /* // 创建一个可运行的对象 MyRunnable myRunnable = new MyRunnable(); // 将可运行的对象封装成一个线程对象 Thread thread = new Thread(myRunnable);*/ //合并以上两行代码 Thread thread = new Thread(new MyRunnable()); // 启动线程 thread.start(); for(int i = 0; i < 100; i++){ System.out.println("main线程--->" + i); } } } // 这并不是一个线程类，是一个可运行的类。它还不是一个线程。 class MyRunnable implements Runnable{ @Override public void run() { for(int i = 0;i < 100;i++) { System.out.println("分支线程--->" + i); } } }将以上代码采用匿名内部类的方式写
package Thread; public class ThreadTest03 { public static void main(String[] args) { Thread thread = new Thread(new Runnable() { @Override public void run() { for(int i = 0;i < 10;i++) { System.out.println("分支线程--->" + i); } } }); thread.start(); for(int i = 0; i < 10; i++){ System.out.println("main线程--->" + i); } } }**注意：**第二种方式实现接口比较常用，因为一个类实现了接口，它还可以去继承其它的类，更灵活。
第三种方式：实现Callable接口。（JDK8新特性。）这种方式实现的线程可以获取线程的返回值。之前讲解的那两种方式是无法获取 线程返回值的，因为run方法返回void。
package Thread; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; public class ThreadTest13 { public static void main(String[] args) { // 第一步：创建一个“未来任务类”对象。 // 参数非常重要，需要给一个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; } }); // 创建线程对象 Thread t = new Thread(task); // 启动线程 t.start(); // 这里是main方法，这是在主线程中。 // get()方法的执行会导致“当前线程阻塞” Object obj = null; try { obj = task.get(); System.out.println("线程执行结果:" + obj); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } // main方法这里的程序要想执行必须等待get()方法的结束 // 而get()方法可能需要很久。因为get()方法是为了拿另一个线程的执行结果 System.out.println("hello world!"); } }优点：可以获取到线程的执行结果。
缺点：在获取t线程执行结果的时候，当前线程受阻塞，效率较低。
-
线程对象的生命周期
二、线程的方法
-
线程的常用方法
-
获取当前线程对象：
Thread t = Thread.currentThread(); 返回值t就是当前线程。出现在main方法，当前线程就是主线程 -
获取线程对象的名字
String name = 线程对象.getName(); -
修改线程对象的名字
线程对象.setName("线程名字");当线程没有设置名字的时候，默认的名字的规律：
Thread-0
Thread-1
Thread-2
Thread-3
…
-
-
关于线程的sleep方法
static void sleep(long millis)（1）静态方法：Thread.sleep(1000);
（2）参数是毫秒
（3）作用：让当前线程进入休眠，进入“阻塞状态”，放弃占有CPU时间片，让给其它线程使用。
这行代码出现在A线程中，A线程就会进入休眠。
这行代码出现在B线程中，B线程就会进入休眠。
（4）Thread.sleep()方法，可以做到这种效果：间隔特定的时间，去执行一段特定的代码，每隔多久执行一次。
package Thread;
public class ThreadTest04 {
public static void main(String[] args) {
for(int i = 0; i < 10; i++){
System.out.println(Thread.currentThread().getName() + "--->" + i);
// 睡眠1秒
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
（5）sleep方法的面试题
package Thread;
public class ThreadTest05 {
public static void main(String[] args) {
// 创建线程对象
Thread t = new MyThread3();
t.setName("t");
t.start();
// 调用sleep方法
try {
// 问题：这行代码会让线程t进入休眠状态吗？
t.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 5秒之后这里才会执行。
System.out.println("hello World!");
}
}
class MyThread3 extends Thread {
public void run(){
for(int i = 0; i < 10000; i++){
System.out.println(Thread.currentThread().getName() + "--->" + i);
}
}
}
答案是：不会。
在执行的时候还是会转换成：Thread.sleep(1000 * 5);这行代码的作用是：让当前线程进入休眠，也就是说main线程进入休眠。这样代码出现在main方法中，main线程睡眠。即是出现在哪个线程让哪个线程睡眠。
-
终止线程的睡眠
（1）interrupt方法
叫醒一个正在睡眠的线程，这个方法不是终断线程的执行，是终止线程的睡眠。
package Thread; public class ThreadTest06 { public static void main(String[] args) { Thread thread = new Thread(new MyRunnable2()); thread.setName("t"); thread.start(); //五秒之后，主线程执行完想要执行分支线程，需要t线程结束睡眠 try { Thread.sleep(1000 * 5); } catch (InterruptedException e) { e.printStackTrace();//这里将异常追踪信息打印出来 } // 终断t线程的睡眠（这种终断睡眠的方式依靠了java的异常处理机制。） thread.interrupt(); } } class MyRunnable2 implements Runnable{ @Override public void run() { System.out.println(Thread.currentThread().getName() + "----> begin"); try { Thread.sleep( 1000 * 60 * 60 * 24 * 365); } catch (InterruptedException e) { e.printStackTrace(); } //按理来说，这行代码需要一年之后才会执行 System.out.println(Thread.currentThread().getName() + "----> over"); } }（2）强行终止线程的执行——stop
package Thread; public class ThreadTest07 { public static void main(String[] args) { Thread thread = new Thread(new MyRunnable3()); thread.setName("t"); thread.start(); // 模拟5秒 try { Thread.sleep(1000 * 5); } catch (InterruptedException e) { e.printStackTrace(); } // 5秒之后强行终止t线程 thread.stop(); // 已过时（不建议使用。） } } class MyRunnable3 implements Runnable { @Override public void run() { for(int i = 0; i < 10; i++){ System.out.println(Thread.currentThread().getName() + "--->" + i); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }这种方式存在很大的缺点：容易丢失数据。因为这种方式是直接将线程杀死了，线程没有保存的数据将会丢失。不建议使用。
（3）合理的终止
package Thread;public class ThreadTest08 { public static void main(String[] args) { MyRunnable4 r = new MyRunnable4(); Thread thread = new Thread(r); thread.setName("t"); thread.start(); // 模拟5秒 try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } // 你想要什么时候终止t的执行，那么你把标记修改为false，就结束了。 r.run = false; }}class MyRunnable4 implements Runnable{ boolean run = true; @Override public void run() { for(int i = 0; i < 10; i++){ if(run){ System.out.println(Thread.currentThread().getName() + "--->" + i); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } }else{ // return就结束了，结束之前还有什么没保存的,在这里可以保存。save.... //终止当前线程 return; } } }}
三、线程调度
-
常见的线程调度模型
抢占式调度模型：
那个线程的优先级比较高，抢到的CPU时间片的概率就高一些/多一些。
java采用的就是抢占式调度模型。均分式调度模型：
平均分配CPU时间片。每个线程占有的CPU时间片时间长度一样。
有一些编程语言，线程调度模型采用的是这种方式。 -
java中和线程调度有关系的方法
实例方法：
void setPriority(int newPriority) 设置线程的优先级
int getPriority() 获取线程优先级
最低优先级1
默认优先级是5
最高优先级10
优先级比较高的获取CPU时间片可能会多一些。（但也不完全是，大概率是多的。） void join() 合并线程
class MyThread1 extends Thread {
public void doSome(){
MyThread2 t = new MyThread2();
t.join(); // 当前线程进入阻塞，t线程执行，直到t线程结束。当前线程才可以继续。
}
} class MyThread2 extends Thread{
}
静态方法：
static void yield() 让位方法
暂停当前正在执行的线程对象，并执行其他线程
yield()方法不是阻塞方法。让当前线程让位，让给其它线程使用。
yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”。
注意：在回到就绪之后，有可能还会再次抢到。（1）线程的优先级
package Thread; public class ThreadTest09 { public static void main(String[] args) { Thread.currentThread().setPriority(1); /*System.out.println("最高优先级" + Thread.MAX_PRIORITY); System.out.println("最低优先级" + Thread.MIN_PRIORITY); System.out.println("默认优先级" + Thread.NORM_PRIORITY);*/ // 获取当前线程对象，获取当前线程的优先级 Thread currentThread = Thread.currentThread(); // main线程的默认优先级是：5 //System.out.println(currentThread.getName() + "线程的默认优先级是：" + currentThread.getPriority()); Thread t = new Thread(new MyRunnable5()); t.setPriority(10); t.setName("t"); 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() { // 获取线程优先级 //System.out.println(Thread.currentThread().getName() + "线程的默认优先级：" + Thread.currentThread().getPriority()); for(int i = 0; i < 10000; i++){ System.out.println(Thread.currentThread().getName() + "-->" + i); } } }（2）线程让位
让位，当前线程暂停，回到就绪状态，让给其它线程。
静态方法：Thread.yield();package Thread; public class ThreadTest10 { public static void main(String[] args) { Thread t = new Thread(new MyRunnable6()); t.setName("t"); t.start(); for(int i = 1; i <= 1000; i++) { System.out.println(Thread.currentThread().getName() + "--->" + i); } } } class MyRunnable6 implements Runnable { @Override public void run() { for(int i = 1; i <= 1000; i++) { //每100个让位一次。 if(i % 100 == 0){ Thread.yield(); // 当前线程暂停一下，让给主线程。 } System.out.println(Thread.currentThread().getName() + "--->" + i); } } }（3）线程合并
package Thread;public class ThreadTest11 { 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 < 10; i++){ System.out.println(Thread.currentThread().getName() + "--->" + i); } }}
-
四、线程安全
-
数据在多线程并发环境下存在安全问题的条件
①多线程并发
②有共享数据
③共享数据有修改的行为
-
解决线程安全——使用“线程同步机制”
线程排队执行。（不能并发）这种机制被称为：线程同步机制。
线程同步就是线程排队执行，线程排队执行会牺牲部分效率。只有在数据安全的情况下才能谈效率。
-
异步编程模型：
线程t1和线程t2，各自执行各自的，t1不管t2，t2不管t1，谁也不需要等谁，这种编程模型叫做：异步编程模型。
其实就是：多线程并发（效率较高。）异步就是并发。同步编程模型：
线程t1和线程t2，在线程t1执行的时候，必须等待t2线程执行结束，或者说在t2线程执行的时候，必须等待t1线程执行结束，
两个线程之间发生了等待关系，这就是同步编程模型。效率较低。线程排队执行。同步就是排队。 -
编写程序模拟采用ATM机和人工窗口同时对一个银行账户取款
（1）不使用线程同步机制
package ThreadSafe;/*银行账户 */public class Account { //账号 private int num; //余额 private double balance; public Account() { } public Account(int num, double balance) { this.num = num; this.balance = balance; } public int getNum() { return num; } public void setNum(int num) { this.num = num; } public double getBalance() { return balance; } public void setBalance(double balance) { this.balance = balance; } //取款的方法 public void whihdraw(double money){ //取款前的余额 double before = this.getBalance(); //取款后的余额 double after = before - money; //更新余额 this.setBalance(after); }}package ThreadSafe; /* 账户线程 */ public class AccountThread extends Thread{ //保证共享同一个账户对象 private Account act; //通过构造方法传递过来账户对象 public AccountThread(Account act){ this.act = act; } public void run(){ //run方法的执行表示进行取款操作 double money = 5000; act.withdraw(money); System.out.println(Thread.currentThread().getName() + "对" + act.getNo() + "取款成功，余额还剩：" + act.getBalance()); } }package ThreadSafe; public class Test { public static void main(String[] args) { // 创建账户对象（只创建1个） Account act = new Account("CoolEr",10000); // 创建两个线程 Thread t1 = new AccountThread(act); Thread t2 = new AccountThread(act); // 设置name t1.setName("人工窗口"); t2.setName("ATM"); // 启动线程取款 t1.start(); t2.start(); } }结果导致：可能ATM和人工窗口对存有10000元的账户都进行了取款5000的操作，但是最后账户余额为5000。
（2）使用线程同步机制
package ThreadSafe; /* 银行账户 */ public class Account { //账户 private String no; //余额 private double balance; public Account() { } public Account(String no, double balance) { this.no = no; this.balance = balance; } public String getNo() { return no; } public void setNo(String no) { this.no = no; } public double getBalance() { return balance; } public void setBalance(double balance) { this.balance = balance; } //取款的方法 public void withdraw(double money){ //以下的代码必须是一个线程执行完毕之后，另外一个线程才可以执行 synchronized (this){ //取款前的余额 double before = this.getBalance(); //取款后的余额 double after = before - money; try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } //更新余额 this.setBalance(after); } } }①线程同步机制的语法：
synchronized(){ // 线程同步代码块。 } synchronized后面小括号中传的这个“数据”是相当关键的。这个数据必须是多线程共享的数据。才能达到多线程排队。()中写什么？ 那要看你想让哪些线程同步。
假设t1、t2、t3、t4、t5，有5个线程，你只希望t1 t2 t3排队，t4 t5不需要排队。你一定要在()中写一个t1 t2 t3共享的对象。而 这个对象对于t4 t5来说不是共享的。在java语言中，任何一个对象都有“一把锁”，其实这把锁就是标记。（只是把它叫做锁。）100个对象，100把锁。1个对象1把锁。
-
对synchronized的理解
（1）如果在以上Account类中添加Object obj = new Object();obj这个实例变量也可以写在synchronized()中。
（2）有线程安全问题的变量
Java中有三大变量：
实例变量：在堆中。
静态变量：在方法区。
局部变量：在栈中。
以上三大变量中：
局部变量永远都不会存在线程安全问题。因为局部变量不共享。（一个线程一个栈。）局部变量在栈中。所以局部变量永远不 会共享。如果使用局部变量的话：建议使用：StringBuilder。StringBuffer效率比较低。 实例变量在堆中，堆只有1个。
静态变量在方法区中，方法区只有1个。
堆和方法区都是多线程共享的，所以可能存在线程安全问题。 **结论：**局部变量+常量：不会有线程安全问题。
成员变量：可能会有线程安全问题。（3）synchronized出现在实例方法中
缺点：
①synchronized出现在实例方法上，一定锁的是this。没得挑。只能是this。不能是其他的对象。所以这种方式不灵活。
②synchronized出现在实例方法上，表示整个方法体都需要同步，可能会无故扩大同步的范围，导致程序的执行效率降低。所 以这种方式不常用。
优点：
代码少。
如果共享的对象就是this，并且需要同步的代码块是整个方法体，建议使用这种方式。
（4）ArrayList是非线程安全的。
Vector是线程安全的。
HashMap HashSet是非线程安全的。
Hashtable是线程安全的。（5）synchronized的三种写法
第一种：同步代码块
灵活
synchronized(线程共享对象){
同步代码块;
} 第二种：在实例方法上使用synchronized
表示共享对象一定是this，并且同步代码块是整个方法体。 第三种：在静态方法上使用synchronized表示找类锁。类锁永远只有1把。就算创建了100个对象，那类锁也只有一把。
对象锁：1个对象1把锁，100个对象100把锁。
类锁：100个对象，也可能只是1把类锁。（6）synchronized面试题
①观察以下程序，思考doOther方法执行的时候需要等待doSome方法的结束吗？
不需要，因为doOther()方法没有synchronized。执行doOther()方法的时候并不需要锁。package exam1;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(){ 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"); }} ②面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
需要。package exam2; 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(){ System.out.println("doSome begin"); try { Thread.sleep(1000 * 10); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("doSome over"); } public synchronized void doOther(){ System.out.println("doOther begin"); System.out.println("doOther over"); } } ③面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
不需要，因为MyClass对象是两个，两把锁。package exam3; 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(){ System.out.println("doSome begin"); try { Thread.sleep(1000 * 10); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("doSome over"); } public synchronized void doOther(){ System.out.println("doOther begin"); System.out.println("doOther over"); } } ④ 面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
需要，因为静态方法是类锁，不管创建了几个对象，类锁只有1把。package exam4; 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(){ 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(){ System.out.println("doOther begin"); System.out.println("doOther over"); } } -
死锁概述
package deadock;
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){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (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){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (o1){
}
}
}
}
在日后的开发中，synchronized不要嵌套使用。
-
开发中解决线程问题
synchronized会让程序的执行效率降低，用户体验不好。系统的用户吞吐量降低。用户体验差。在不得已的情况下再选择线程同步机制。所以按照以下方案进行选择：
第一种方案：尽量使用局部变量代替“实例变量和静态变量”。
第二种方案：如果必须是实例变量，那么可以考虑创建多个对象，这样实例变量的内存就不共享。（一个线程对应1个对象，100个 线程对应100个对象，对象不共享，就没有数据安全问题了。）
第三种方案：如果不能使用局部变量，对象也不能创建多个，这个时候就只能选择synchronized了。线程同步机制。
五、守护线程
-
java语言中线程分为两大类：
一类是：用户线程
一类是：守护线程（后台线程）
其中具有代表性的就是：垃圾回收线程（守护线程）。 -
守护线程的特点：
一般守护线程是一个死循环，所有的用户线程只要结束，守护线程自动结束。**注意：**主线程main方法是一个用户线程。
-
守护线程用在什么地方？
例如：每天00:00的时候系统数据自动备份。这个需要使用到定时器，并且我们可以将定时器设置为守护线程。一直在那里看着，没到00:00的时候就备份一次。所有的用户线程如果结束了，守护线程自动退出，没有必要进行数据备份了。 -
实现守护线程
package Thread; public class ThreadTest12 { public static void main(String[] args) { Thread t = new BakDataThread(); t.setName("备份数据的线程"); // 启动线程之前，将线程设置为守护线程 t.setDaemon(true); t.start(); // 主线程：主线程是用户线程 for(int i = 0; i < 10; i++){ 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(); } } } }主线程用户线程结束，守护线程必须结束
六、定时器
-
定时器的作用：间隔特定的时间，执行特定的程序。
-
在实际的开发中，每隔多久执行一段特定的程序，这种需求是很常见的，那么在java中其实可以采用多种方式实现：
（1）可以使用sleep方法，睡眠，设置睡眠时间，没到这个时间点醒来，执行任务。这种方式是最原始的定时器。（比较low）
（2）在java的类库中已经写好了一个定时器：java.util.Timer，可以直接拿来用。不过，这种方式在目前的开发中也很少用，因为现 在有很多高级框架都是支持定时任务的。
（3）在实际的开发中，目前使用较多的是Spring框架中提供的SpringTask框架，这个框架只要进行简单的配置，就可以完成定时器 的任务。
-
实现定时器
package Thread; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; import java.util.Timer; import java.util.TimerTask; public class TimerTest01 { public static void main(String[] args) { Timer timer = new Timer(); //Timer timer = new Timer(true); //守护线程的方式 //timer.schedule(定时任务, 第一次执行时间, 间隔多久执行一次); //timer.schedule(new LogTimerTask() , firstTime, 1000 * 60 * 60 * 24 * 365);// 每年执行一次。 try { SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); Date firstTime = sdf.parse("2022-01-01 17:12:00"); timer.schedule(new LogTimerTask(),firstTime,1000 * 10); //也可以采用匿名内部类 //timer.schedule(new TimerTask(){ // @Override // public void run() { // // code.... // } // } , firstTime, 1000 * 10); } catch (ParseException e) { e.printStackTrace(); } } } // 编写一个定时任务类,假设这是一个记录日志的定时任务 class LogTimerTask extends TimerTask { @Override public void run() { // 编写需要执行的任务。 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); String strTime = sdf.format(new Date()); System.out.println(strTime + ":成功完成了一次数据备份！"); } }
七、关于Object的wait和notify方法
-
wait和notify方法不是线程对象的方法，是java中任何一个java对象都有的方法，因为这两个方式是Object类中自带的。wait方法和notify方法不是通过线程对象调用。
-
wait()方法作用
Object o = new Object();
o.wait();表示：
让正在o对象上活动的线程进入等待状态，无期限等待，直到被唤醒为止。o.wait();方法的调用，会让“当前线程（正在o对象上
活动的线程）”进入等待状态。并且释放掉t线程之前占有的o对象的锁。 -
notify()方法作用
Object o = new Object();
o.notify();表示：
让正在o对象上等待的线程唤醒，只是通知，不会释放o对象上之前占有的锁。还有一个notifyAll()方法：这个方法是唤醒o对象上处于等待的所有线程。
-
wait方法和notify方法建立在线程同步的基础之上。
-
生产者和消费者模式
生产线程负责生产，消费线程负责消费。
生产线程和消费线程要达到均衡。这是一种特殊的业务需求，在这种特殊的情况下需要使用wait方法和notify方法。 -
使用wait方法和notify方法实现“生产者和消费者模式”
需求：
仓库我们采用List集合。
List集合中假设只能存储1个元素。
1个元素就表示仓库满了。
如果List集合中元素个数是0，就表示仓库空了。
保证List集合中永远都是最多存储1个元素。 必须做到这种效果：生产1个消费1个。
package Thread; import java.util.ArrayList; import java.util.List; public class ThreadTest14 { 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.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.notifyAll(); } } } }
49
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
