文章目录
- 一. 多线程概述
- 1. 什么是进程？什么是线程？
- 2. 进程和线程的关系
- 3. 多线程并发
- 4. 分析以下程序有几个线程
- 5. Java实现线程的两种方式
- 5.1 第一种方式
- 5.2 第二种方式
- 5.3 采用匿名内部类
- 6. 线程的生命周期
- 二. 线程的常用方法
- 1. 获取线程的名字
- 2. 获取当前线程对象
- 3. 线程的sleep方法
- 三. 线程调度概述
- 1. 常见的线程调度模型有哪些？
- 2. java中提供哪些方法是和线程调度有关系的
- 四. 多线程并发环境下，数据的安全问题
- 1. 为什么这个是重点？
- 2. 什么时候数据在多线程并发的环境下会存在安全问题？
- 3. 怎么解决线程安全问题？
- 4. 同步和异步理解
- 5. 对synchronize的理解
- 6. 哪些变量有线程安全问题？
- 7. synchronized出现在实例方法上
- 8. synchronized三种用法
- 五. 面试题
- 1. doOther方法执行的时候需要等待doSome方法的结束吗？
- 六. 死锁
- 七. 线程这块的其他内容
- 1. 守护线程
- 2. 定时器
- 3. 实现线程的第三种方式
- 4. 关于Object类中的wait和notify方法（生产者和消费者模式）
一. 多线程概述
1. 什么是进程？什么是线程？
- 进程是一个应用程序（一个进程是一个软件）
- 线程是一个进程中的执行场景/执行单元
- 一个进程可以启动多个线程
对应java程序员来说，当在DOS命令窗口中输入：
- java HelloWorld 回车之后
- 会先启动JVM，而JVM就是一个进程
- JVM再启动一个主线程调用main方法
- 同时再启动一个垃圾回收线程负责看护，回收垃圾
- 最起码，现在的java程序中至少有两个线程并发
- 一个是垃圾回收线程，一个是执行main方法的主线程
2. 进程和线程的关系
进程A和进程B的内存独立不共享
- 音乐是一个进程
- 视频是一个进程
- 两个进程独立，不共享资源
在Java语言中线程A和线程B，堆内存和方法区内存共享
但是栈内存独立，一个线程一个栈
- 假设启动10个线程，会有10个栈空间，每个栈和每个栈之间，互不干扰，各自执行各自的，这就是多线程并发
Java中之所以有多线程机制，目的就是为了提高程序的处理效率
使用了多线程机制之后，main方法结束了，只是主线程结束了，主栈空了，其他的栈（线程）可能还在压栈弹栈
一个线程一个栈
3. 多线程并发
什么是多线程并发？
- t1线程执行t1的
- t2线程执行t2的
- t1不会影响t2，t2也不会影响t1.这叫做真正的多线程并发
对于多核CPU，真正的多线程并发是没有问题的
- 单核CPU不能真正的做到多线程并发，但是可以给人一种“多线程并发”的感觉
4. 分析以下程序有几个线程
除了垃圾回收线程之外，有几个？
package com.pudding.thread;
/*
main begin
m1 begain
m2 begain
m3 execute
m2 over
m1 over
main over
一个栈中自上而下的顺序逐行执行
*/
public class ThreadTest01 {
public static void main(String[] args) {
System.out.println("main begin");
m1();
System.out.println("main over");
}
private static void m1() {
System.out.println("m1 begain");
m2();
System.out.println("m1 over");
}
private static void m2() {
System.out.println("m2 begain");
m3();
System.out.println("m2 over");
}
private static void m3() {
System.out.println("m3 execute");
}
}
5. Java实现线程的两种方式
5.1 第一种方式
编写一个类，直接继承java.lang.Thread，重写run方法
public class MyThread extends Thread{
public void run(){
}
}
//创建线程对象
MyThread t = new MyThread();
//启动
t.start();怎么创建对象？
- new就行了
怎么启动线程
- 调用线程对象的start()方法
package com.pudding.thread;
/*
实现线程的第一种方式：
编写一个类，直接继承java.lang.Thread,重写run方法
*/
public class ThreadTest02 {
public static void main(String[] args) {
//这里是main方法，这里的代码属于主线程，在主栈中运行
//新建一个分支线程
MyThread myThread = new MyThread();
//启动线程
myThread.run(); //不会启动线程，不会分配新的分支栈（这种方式就是单线程）
//start()方法作用：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成之后，瞬间就结束了
//这段代码的任务只是为了开启一个新的栈空间，只有新的栈空间开出来，start()方法就结束了，线程就启动成功了
//启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部
//run方法在分支栈的栈底部，main方法在主栈的栈底部，run和main是平级的
myThread.start();
//这里的代码还是运行在主线程中
for (int i = 0;i<100;i++){
System.out.println("主线程..." + i);
}
}
}
class MyThread extends Thread{
@Override
public void run() {
//编写程序，这段程序运行在分支栈
for (int i = 0;i<100;i++){
System.out.println("分支线程..." + i);
}
}
}
注run和start的区别
- 线程run
- 线程start
以上程序的输出结果有这样的特点： - 有先有后
- 有多有少
5.2 第二种方式
编写一个类，实现java.lang.Runnable接口，实现run方法。
package com.pudding.thread;
public class ThreadTest03 {
public static void main(String[] args) {
//创建一个可运行的对象
//MyRunnable r = new MyRunnable();
//将可运行的对象封装成一个线程对象
//Thread t = new Thread(r);
//合并代码
Thread t = new Thread(new MyRunnable());
//启动线程
t.start();
for (int i = 0;i<100;i++){
System.out.println("主线程..." + i);
}
}
}
//这并不是一个线程类，是一个可运行的类，它还不是一个线程
class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 0;i<100;i++){
System.out.println("分支线程..." + i);
}
}
}
注意：第二种方式实现接口比较常见，因为一个类实现了接口，它还可以去继承其他的类，更灵活
5.3 采用匿名内部类
package com.pudding.thread;
public class ThreadTest04 {
public static void main(String[] args) {
//创建线程对象，采用匿名内部类方式
Thread t = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i<100;i++){
System.out.println("t线程..." + i);
}
}
});
//启动线程
t.start();
for (int i = 0;i<100;i++){
System.out.println("main线程..."+i);
}
}
}
6. 线程的生命周期
二. 线程的常用方法
1. 获取线程的名字
获取线程对象的名字
- String name = 线程对象.getName();
修改线程对象的名字
- 线程对象.setName(“线程名字”);
当线程没有设置名字的时候，默认的名字有什么规律？
- Thread-0
- Thread-1
package com.pudding.thread;
public class ThreadTest05 {
public static void main(String[] args) {
//创建线程对象
MyThread2 t = new MyThread2();
//设置线程的名字
//t.setName("tttt");
//获取线程的名字
String tName = t.getName();
System.out.println(tName); //默认线程的名字:Thread-0
MyThread2 t2 = new MyThread2();
System.out.println(t2.getName()); //Thread-1
//启动线程
t.start();
}
}
class MyThread2 extends Thread{
public void run(){
for (int i = 0; i < 100; i++) {
System.out.println("分支线程-->" + i);
}
}
}
2. 获取当前线程对象
- static Thread currentThread()
- Thread t = Thread.currentThread(); 返回值t就是当前线程
package com.pudding.thread;
public class ThreadTest05 {
public static void main(String[] args) {
//currentThread就是当前线程对象
//这个代码出现在main方法当中，所有当前线程就是主线程
Thread currentThread = Thread.currentThread();
System.out.println(currentThread.getName()); //main
//创建线程对象
MyThread2 t = new MyThread2();
//设置线程的名字
//t.setName("tttt");
//获取线程的名字
String tName = t.getName();
System.out.println(tName); //默认线程的名字:Thread-0
MyThread2 t2 = new MyThread2();
System.out.println(t2.getName()); //Thread-1
//启动线程
t.start();
t2.start();
}
}
class MyThread2 extends Thread{
public void run(){
for (int i = 0; i < 100; i++) {
//currentThread就是当前线程
//t1线程执行run方法，那么这个当前线程就是t1
Thread currentThread = Thread.currentThread();
System.out.println(currentThread.getName() + "-->" + i);
}
}
}
3. 线程的sleep方法
static void sleep(long millis)
- 静态方法
- 参数是毫秒
- 作用：让当前线程进入休眠，进入“阻塞状态”放弃占有CPU时间片，让给其他线程使用
- 这段代码出现在A线程中，A线程就会进入休眠
- Thread.sleep()方法，可以做到这种效果：间隔特定的时间，去执行一段特定的代码，每隔多久执行一次
package com.pudding.thread;
public class ThreadTest06 {
public static void main(String[] args) {
//让当前线程进入休眠，睡眠5秒
//当前线程是主线程
/*try {
Thread.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}
//5秒之后执行此处代码
System.out.println("hello world！");*/
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
package com.pudding.thread;
public class ThreadTest07 {
public static void main(String[] args) {
//创建线程对象
Thread t = new MyThread3();
t.setName("t");
t.start();
//调用sleep方法
try {
//问题：这行代码会让线程t进入休眠状态？ 不会
t.sleep(1000 * 5); //在执行的时候还是会转换成：Thread.sleep(1000*5)
//这行代码的作用是：让当前线程进入休眠，也就是说main线程进入休眠
//这样代码出现在main方法中，main线程睡眠
} catch (InterruptedException e) {
e.printStackTrace();
}
//5秒之后这里才会执行
System.out.println("hello world");
}
}
class MyThread3 extends Thread{
public void run(){
for (int i = 0; i < 1000; i++) {
System.out.println(Thread.currentThread().getName() + "--->" + i);
}
}
}
sleep睡眠太久了，怎么叫醒一个正在睡眠的线程？？
- 注意：这个不是中断线程的执行，是终止线程的睡眠
package com.pudding.thread;
public class ThreadTest08 {
public static void main(String[] args) {
Thread t = new Thread(new MyRunnable2());
t.setName("t");
t.start();
//希望5秒之后，t线程醒来
try {
Thread.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}
//中断t线程睡眠(这种中断睡眠的方式依靠了java的异常处理机制)
t.interrupt();
}
}
class MyRunnable2 implements Runnable{
//重点：run()当中的异常不能throws，只能try catch
//因为run()方法在父类中没有抛出任何异常，子类不能比父类抛出更多的异常
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "---> begin");
//睡眠1年
try {
//睡眠1年
Thread.sleep(1000 * 60 * 60 * 24 * 365);
} catch (InterruptedException e) {
//打印异常信息
e.printStackTrace();
}
//1年之后才会执行这里
System.out.println(Thread.currentThread().getName() + "---> end");
}
}
强行终止线程的执行
- 这种方式存在很大的缺点：容易丢失数据。因为这种方式是直接将线程杀死了，线程没有保存的数据将会丢失。不建议使用
package com.pudding.thread;
public class ThreadTest09 {
public static void main(String[] args) {
Thread t = new Thread(new MyRunnable3());
t.setName("t");
t.start();
//模拟5秒
try {
Thread.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}
//5秒之后强行终止t线程
t.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();
}
}
}
}
我们应该合理的终止线程的执行，这种方式是很常用的
package com.pudding.thread;
public class ThreadTest10 {
public static void main(String[] args) {
MyRunable4 r = new MyRunable4();
Thread t = new Thread(r);
t.setName("t");
t.start();
//模拟5秒
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//终止线程
//想要什么时候终止t的执行，把标记改为false即可
r.run = false;
}
}
class MyRunable4 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之前都可以进行保存内容
return;
}
}
}
}
三. 线程调度概述
1. 常见的线程调度模型有哪些？
抢占式调度模型
- 哪个线程的优先级比较高，抢到的CPU时间片的概率就高一些
- Java采用的就是抢占式调度模型
均分时调度模型
- 平均分配CPU时间片，每个线程占有的CPU时间片时间长度一样
- 平均分配，一切平等
2. java中提供哪些方法是和线程调度有关系的
实例方法？
- void setPriority(int newPriority) 设置线程的优先级
- int getPriority() 获取线程的优先级
- 最低优先级：1
- 默认优先级：5
- 最高优先级：10
静态方法：
- static void yield() 让位方法：暂停当前正在执行的线程对象，并执行其他线程
- yield()方法不是阻塞方法，让当前线程让位，让给其他线程使用
- yield()方法的执行会让当前线程从"运行状态"回到"就绪状态"，之后还可以抢到
实例方法：
- void join()
合并线程
class MyThread{
public void doSome(){
MyThread2 t = new MyThread2();
t.join(); //当前线程进入阻塞，t线程执行，直到t线程结束。当前线程才可以执行
}
}
class MyThread2 extends Thread{
}
package com.pudding.thread;
/*
关于线程的优先级
*/
public class ThreadTest11 {
public static void main(String[] args) {
//设置主线程优先级为1
Thread.currentThread().setPriority(1);
System.out.println("最高优先级" + Thread.MAX_PRIORITY); //10
System.out.println("最低优先级" + Thread.MIN_PRIORITY); //1
System.out.println("默认优先级" + Thread.NORM_PRIORITY); //5
//获取当前线程对象，获取当前线程优先级
Thread currentThread = Thread.currentThread();
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 < 1000; 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 < 1000; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}
package com.pudding.thread;
/*
让位：当前线程暂停，回到就绪状态，让给其他线程
*/
public class ThreadTest12 {
public static void main(String[] args) {
Thread t = new Thread(new MyRunnable6());
t.setName("t");
t.start();
for (int i = 0; i <= 10000; i++) {
System.out.println(Thread.currentThread().getName()+ "-->" + i);
}
}
}
class MyRunnable6 implements Runnable{
@Override
public void run() {
for (int i = 0; i <= 10000; i++) {
//每100个让位一次
if (i%100 == 0){
Thread.yield();//当前线程暂停一下，让给主线程
}
System.out.println(Thread.currentThread().getName()+ "-->" + i);
}
}
}
package com.pudding.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 < 100; i++) {
System.out.println(Thread.currentThread().getName() + "--->" + i);
}
}
}
四. 多线程并发环境下，数据的安全问题
1. 为什么这个是重点？
以后在开发中，我们的项目都是运行在服务器中，而服务器已经将线程的定义，线程对象的创建，线程的启动等，都已经实现了。这些代码我们都不需要编写。
- 最重要的是：你要知道，你编写的程序需要放到一个多线程的环境下运行，你更需要关注的是这些数据在多线程并发的环境下是否是安全的
2. 什么时候数据在多线程并发的环境下会存在安全问题？
三个条件
- 条件1：多线程并发
- 条件2：有共享数据
- 条件3：共享数据有修改的行为
3. 怎么解决线程安全问题？
当多线程并发的环境下，有共享数据，并且这个数据还会被修改，此时就存在线程安全问题，怎么解决？
- 线程排队执行（不能并发）
- 用排队执行解决线程安全问题。
- 这种机制被称为：线程同步机制
- 专业术语叫做：线程同步，实际上就是线程不能并发，线程必须排队执行
- 线程同步就是线程排队了，线程排队就会牺牲一部分效率，没办法，数据安全第一位。
4. 同步和异步理解
同步编程模型：
- 线程t1和线程t2，在线程t1执行的时候，必须等待t2线程执行结束，或者说在t2线程执行的时候，必须等待t1线程执行结束，两个线程之间发生了等待关系
- 同步就是排队（效率较低）
异步编程模型：
- 线程t1和线程t2，各自执行各自的，t1不管t2，t2不管t1，谁也不需要等谁，这种编程模型叫做：异步编程模型
- 异步就是并发（效率较高）
不使用线程同步机制，多线程对同一账户进行取款，出现线程安全问题
package com.pudding.threadsafe;
/*
银行账户
不使用线程同步机制，多线程对同一账户进行取款，出现线程安全问题
*/
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是两个栈，两个栈操作堆中同一个对象）
//取款之前的余额
double before = this.getBalance();
//取款之后的余额
double after = before - money;
//更新余额
//这里模拟网络延时
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//如果：t1执行到这里，但是还没有来得及执行这行代码，t2线程进来withdraw方法了。此时一定出问题
this.setBalance(after);
}
}
package com.pudding.threadsafe;
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());
}
}
package com.pudding.threadsafe;
public class Test {
public static void main(String[] args) {
//创建账户对象
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();
}
}
5. 对synchronize的理解
package com.pudding.threadsafe2;
/*
银行账户
使用线程同步机制，解决线程安全问题
*/
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){
//以下这几行代码必须是线程排队的，不能并发
//一个线程把这里的代码全部执行结束之后，另一个线程才能进来
/*
线程同步机制的语法是：
synchronized (){
//线程同步代码块
}
synchronized 后面小括号中传的这个"数据"是相当关键的。
这个数据必须是多线程共享的数据，才能达到多线程排队
()中写什么？
那你看你想让哪些线程同步
假设t1、t2、t3、t4、t5，有5个线程
你只希望t1、t2、t3排队，t4、t5不需要排队。怎么办？
你一定要在（）中写一个t1、t2、t3共享对象。而这个对象对于t4、t5来说不共享的
这里的共享对象是：账户对象
账户对象是共享的，那么this就是账户对象
不一定是this，这里只要是多线程共享的那个对象就行
*/
synchronized (this){
double before = this.getBalance();
double after = before - money;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setBalance(after);
}
}
}
在Java语言中，任何一个对象都有“一把锁”，其实这把锁就是标记（只是把它叫做锁）
- 100个对象，100把锁
以下代码的执行原理？
- 假设t1和t2线程并发，开始执行以下代码的时候，肯定有一个先一个后。
- 假设t1先执行了，遇到了synchronized，这时候自动找“后面共享对象”的对象锁，找到之后，并占有这把锁，然后执行同步代码块中的程序，在程序执行过程一直都是占有这把锁的。直到同步代码结束，这把锁才会释放
- 假设t1已经占有这把锁，此时t2也遇到synchronized关键字，也会去占有后面共享对象的这把锁，结果这把锁被t1占有，t2只能在同步代码块外面等待t1结束，直到t1把同步代码块执行结束了，t1会归还这把锁，此时t2终于等到这把锁，然后t2占有这把锁之后，进入同步代码块执行程序
这样就达到了线程排队执行
- 这里需要注意的是：这个共享对象一定要选好了。这个共享对象一定是你需要排队执行的这些线程对象所共享的
package com.pudding.threadsafe2;
/*
银行账户
使用线程同步机制，解决线程安全问题
*/
public class Account {
//账号
private String actno;
//余额
private double balance;
//对象
Object obj = new Object(); //实例变量（Account对象是多线程共享的，Account对象中的实例变量obj也是共享的）
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){
//以下这几行代码必须是线程排队的，不能并发
//一个线程把这里的代码全部执行结束之后，另一个线程才能进来
/*
线程同步机制的语法是：
synchronized (){
//线程同步代码块
}
synchronized 后面小括号中传的这个"数据"是相当关键的。
这个数据必须是多线程共享的数据，才能达到多线程排队
()中写什么？
那你看你想让哪些线程同步
假设t1、t2、t3、t4、t5，有5个线程
你只希望t1、t2、t3排队，t4、t5不需要排队。怎么办？
你一定要在（）中写一个t1、t2、t3共享对象。而这个对象对于t4、t5来说不共享的
这里的共享对象是：账户对象
账户对象是共享的，那么this就是账户对象
不一定是this，这里只要是多线程共享的那个对象就行
*/
Object obj2 = new Object(); //这个不可以，是局部变量，不是共享对象
//synchronized ("abc") 这个也可以，在字符串常量池中，所有线程都会同步
//synchronized (null) 报错，空指针
//synchronized (this){
synchronized (obj){
double before = this.getBalance();
double after = before - money;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setBalance(after);
}
}
}
6. 哪些变量有线程安全问题？
Java中有三大变量
- 实例变量：在堆中
- 静态变量：在方法区
- 局部变量：在栈中
以上三大变量中：局部变量永远都不会存在线程安全问题。因为局部变量不共享（一个线程一个栈）局部变量在栈中，所有局部变量不会共享
- 实例变量在堆中，堆只有1个，静态变量在方法区中，方法区只有1个，堆和方法区都是多线程共享的，所以可能存在线程安全问题
注意：synchronized扩的范围越大，效率越低
- 局部变量+常量：不会有线程安全问题
- 成员变量：可能会有线程安全问题
7. synchronized出现在实例方法上
synchronized出现在实例方法上，一定锁的是this。没得挑，只能是this。不能是其他的对象了。所有这种方式不灵活
- 另一个缺点：synchronized出现在实例方法上，表示整个方法都需要同步，可能会无故扩大同步的范围，导致程序的执行效率降低，所以这种方式不常用。
/*
synchronized使用在实例方法上优点：简洁了
*/
public synchronized void withdraw(double money){
double before = this.getBalance();
double after = before - money;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setBalance(after);
}
如果使用局部变量的话，建议使用：StringBuilder
- 因为局部变量不存在线程安全问题，选择StringBuilder效率比较低
8. synchronized三种用法
第一种：同步代码块
- 灵活
synchronized(线程共享对象){
同步代码块
}第二种：在实例方法上使用synchronized
- 表示共享对象一定是this
- 并且同步代码块是整个方法体
第三种：在静态方法上使用synchronized
- 表示找类锁
- 类锁永远只有1把
- 就算创建了100个对象，那类锁也只有1把
对象锁：1个对象1把锁，100个对象100把锁
类锁：100个对象，也可能只是1把类锁
五. 面试题
1. doOther方法执行的时候需要等待doSome方法的结束吗？
不需要，因为doOther方法没有synchronized
package com.pudding.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{
//synchronized出现在实例方法上，表示锁this
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");
}
}
当synchronized出现在静态方法上是找类锁
- 这个时候就需要等待，因为静态方法是类锁，不管创建几个对象，类锁只有1把
六. 死锁
出现死锁，不出现异常，也不出现错误，程序一直僵持在那里
package com.pudding.deadlock;
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 MyThread1(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会让程序的执行效率降低，用户体验不好。系统的用户吞吐量降低。用户体验差。在不得已的情况下再选择线程同步机制
第一种方案：
- 尽量使用局部变量代替“实例变量和静态变量”
第二种方案：
- 如果必须是实例变量，那么可以考虑创建多个对象，这样实例变量的内存就不共享了（1个线程对应1个对象）
第三种方案：
- 如果不能使用局部变量，对象也不能创建多个，这个时候就只能选择synchronized，线程同步机制
七. 线程这块的其他内容
1. 守护线程
Java语言中的线程分为两大类：
- 一类是：用户线程
- 一类是：守护线程（后台线程）
其中具有代表性的就是：垃圾回收线程（守护线程）
守护线程的特点：
- 一般守护线程是一个死循环，所有的用户线程只要结束，守护线程自动结束
注意：主线程main方法是一个用户线程
守护线程用在什么地方呢？
- 每天00:00的时候系统数据自动备份
- 这个需要使用到定时器，并且我们可以将定时器设置为守护线程
- 一直在那里看着，没到00:00的时候就备份一次，所有的用户线程如果结束了，守护线程自动退出，没有必要进行数据备份
package com.pudding.thread;
/*
守护线程
*/
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++) {
System.out.println(Thread.currentThread().getName()+"--->"+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class BakDataThread extends Thread{
@Override
public void run() {
int i = 0;
while (true){
System.out.println(Thread.currentThread().getName()+"--->" + (++i));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
2. 定时器
定时器作用：
- 间隔特定时间，执行特定的程序
- 每天进行数据的备份
在实际开发中，每隔多久执行一段特定的程序，这种需求是很常见的
Java中的实现方式
- 可以实现sleep方法，睡眠，设置睡眠时间，每到这个时间点醒来，执行任务。这种方式是最原始的定时器
- 在java的类库中已经写好了一个定时器：java.util.Timer，可以直接拿来用。不过，这种方式在目前的开发中也很少使用，因为现在有很多高级框架都是支持定时任务的
- 在实际开发中，目前使用较多的是Spring框架中提供的SpringTest框架，这个框架只要进行简单的配置，就可以完成定时器的任务。
package com.pudding.thread;
import java.text.ParseException;
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("2022-2-7 13:51:00");
timer.schedule(new LogTimerTask(),firstTime,1000 * 10); //每10秒执行一次
}
}
//编写一个定时任务
//假设这是一个记录日志的定时任务
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 + "：成功完成了一次数据备份");
}
}
3. 实现线程的第三种方式
- FutureTask方式，实现Callable接口
这种方式的优点：可以获取到线程的执行结果
这种方式的缺点：效率比较低，在获取t线程执行结果的时候，当前线程受阻塞，效率较低
package com.pudding.thread;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask; //JUC包下的，属于java的并发包，老JDK中没有这个包
/*
实现线程的第三种方式：
实现Collable接口
*/
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);
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");
}
}
4. 关于Object类中的wait和notify方法（生产者和消费者模式）
第一：wait和notify方法不是线程对象的方法，是java中任何一个java对象都有的方法，因为这两个方式是Object类中自带的
- wait和notify方法不是通过线程对象调用，不是t.wait()
第二：wait()方法作用
- Object o = new Object();
- o.wait();
- 表示：让正在o对象上活动的线程进入等待状态，无期限等待，直到被唤醒位置。o.wait()方法的调用，会让"当前线程（正在o对象上活动的线程）"进入等待状态
第三：notify()方法作用？
- Object o = new Object();
- o.notify();
- 表示：唤醒正在o对象上等待的线程
- 还有一个notifyAll()方法：这个方法是唤醒o对象上处于等待的所有线程
1.使用wait方法和notify方法实现“生产者和消费者模式”
2. 什么是生产者和消费者模式
- 生产线程负责生产，消费线程负责消费
- 生产线程和消费线程要达到均衡
- 这是一种特殊的业务需求，在这种特殊的情况下需要使用wait方法和notif方法
3.wait和notify方法不是线程对象的方法，是普通java对象都有的方法
4.wait方法和notify方法建立在线程同步的基础之上，因为多线程要同时操作一个仓库，有线程安全问题
5.wait方法作用：o.wait()让正在o对象上活动的线程t进入等待状态，并且是否掉t线程之前占有的o对象的锁
6.notify方法作用：o.notify()让正在o对象上等待的线程唤醒，只是通知，不会释放o对象上之前占有的锁
package com.pudding.thread;
import java.util.ArrayList;
import java.util.List;
/*
模拟这样一个需求：
仓库我们采用List集合
List集合假设只能存储1个元素
1表示存满了，0表示仓库空了
必须做的生产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) //说明仓库已经有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();
}
}
}
}
//消费线程
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){
//仓库已经空了，消费者线程等待，释放list集合锁
try {
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//程序能够执行到这里说明仓库中有数据，进行消费
Object obj = list.remove(0);
System.out.println(Thread.currentThread().getName() + "--->" + obj);
//唤醒生产者生产
list.notify();
}
}
}
}
生产者线程--->java.lang.Object@4eac5792
消费者线程--->java.lang.Object@4eac5792
生产者线程--->java.lang.Object@3a0a5be9
消费者线程--->java.lang.Object@3a0a5be9