Java学习第十章(一)
视频链接：https://www.bilibili.com/video/BV1Rx411876f?p=1
视频范围P757 - P796
目录描述
- 1.多线程基础
-
- 1.1 概念
- 1.2 进程和线程的关系
- 1.3 多线程并发
- 2.多线程实现
-
- 2.1 实现线程的第一种方式
- 2.2 run和start的区别
- 2. 3 实现线程的第二种方式
- 2.4 采用匿名内部类实现线程
- 3.线程生命周期
- 4.获取线程信息
- 5.线程的sleep方法
-
- 5.1 面试题
- 5.2 终止线程的睡眠
- 5.3 强行终止线程的执行
- 5.4 合理终止线程的执行
- 6.线程调度
-
- 6.1 概述
- 6.2 线程优先级
- 6.3 线程让位
- 6.4 线程合并
- 7.线程安全
-
- 7.1 线程不安全条件
- 7.2 解决线程安全问题
- 7.3 同步和异步
- 7.4 编程模拟（不使用线程同步机制）
- 7.5 编程模拟（使用线程同步机制）
- 7.6 synchronized理解
- 7.7 编程模拟
- 7.8 有线程安全问题的变量
- 7.9 扩大同步范围
- 7.10 synchronized出现在实例方法上
- 7.10 synchronized总结
- 8.synchronized面试题
-
- 8.1 面试题一
- 8.2 面试题二
- 8.3 面试题三
- 8.4 面试题四
1.多线程基础
1.1 概念
- 进程：一个应用程序【1个进程是一个软件】
- 线程：一个进程中的执行场景/执行单元
- 一个进程可以启动多个线程
举例：
对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后
1.会先启动JVM，而JVM就是一个进程
2.JVM再启动一个主线程调用main方法
3.同时再启动一个垃圾回收线程负责看护，回收垃圾
最起码，现在的java程序中至少有两个线程并发：一个是垃圾回收线程，一个是执行main方法的主线程
1.2 进程和线程的关系
- 进程可以看做是现实生活当中的公司
- 线程可以看做是公司当中的某个员工
- 进程A和进程B的内存独立不共享
- 在java语言中，线程A和线程B，堆内存和方法区内存共享，但是栈内存独立，一个线程一个栈
- 假设启动10个线程，会有10个栈空间，每个栈和每个栈之间互不干扰，各自执行各自的，这就是多线程并发
- 多线程机制目的就是为了提高程序的处理效率
- 使用多线程机制之后，main方法结束只是主线程结束了，主栈空了，其它的栈(线程)可能还在压栈弹栈
1.3 多线程并发
- 对于多核的CPU电脑来说，真正的多线程并发是没问题的
如：4核CPU表示同一个时间点上，可以真正的有4个进程并发执行 - 真正的多线程并发：t1线程执行t1的；t2线程执行t2的；t1不会影响t2，t2不会影响t1
- 单核的CPU表示只有一个大脑：不能够做到真正的多线程并发，但是可以做到给人一种“多线程并发”的感觉。对于单核的CPU来说，在某一个时间点上实际上只能处理一件事情，但是由于CPU的处理速度极快，多个线程之间频繁切换执行，给人的感觉是：多个事情同时在做！！！
问题：分析以下程序，有几个线程，除垃圾回收线程之外
package thread;
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 begin");
m2();
System.out.println("m1 over");
}
private static void m2() {
System.out.println("m2 begin");
m3();
System.out.println("m2 over");
}
private static void m3() {
System.out.println("m3 execute!");
}
}
答：1个线程(因为程序只有1个栈)
2.多线程实现
java语言中，实现线程有两种方式
- 第一种：编写一个类，直接继承java.lang.Thread，重写run方法
注释：java支持多线程机制，并且java已经将多线程实现了，程序员只需要继承就行
//定义线程类
public class MyThread extends Thread{
public void run(){
}
}
//创建线程对象
MyThread t = new MyThread();
//启动线程
t.start();
- 第二种：编写一个类，实现java.lang.Runnable接口，实现run方法
//定义线程类
public class MyRunnable extends Runnable{
public void run(){
}
}
//创建线程对象
Thread t = new Thread(new MyRunnable());
//启动线程
t.start();
- 注意：第二种方式实现接口比较常用，因为一个类实现了接口，它还可以去继承其它的类，更灵活
2.1 实现线程的第一种方式
package thread;
public class ThreadTest02 {
public static void main(String[] args) {
//这里是main方法，这里的代码属于主线程，在主栈中运行
//新建一个分支线程对象
MyThread t = new MyThread();
//启动线程
//start()方法的作用：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码认为完成之后，瞬间就结束了
//这段代码的任务只是为了开启一个新的栈空间，只要新的栈空间开出来，start()方法就结束了，线程就启动成功了
//启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部（压栈）
//run方法在分支栈的栈底部，main方法在主栈的栈底部，run和main是平级的
t.start();
//这里的代码还是运行在主线程中
for (int i = 0; i < 10; i++) {
System.out.println("主线程--->" + i);
}
}
}
class MyThread extends Thread{
@Override
public void run() {
//编写程序，这段程序运行在分支线程中(分支栈)
for (int i = 0; i < 10; i++) {
System.out.println("分支线程---->" + i);
}
}
}
运行结果：
package thread;
public class ThreadTest02 {
public static void main(String[] args) {
//这里是main方法，这里的代码属于主线程，在主栈中运行
//新建一个分支线程对象
MyThread t = new MyThread();
//启动线程
t.run();//不会启动线程，不会分配新的分支栈(这种方式就是单线程)
//这里的代码还是运行在主线程中
for (int i = 0; i < 10; i++) {
System.out.println("主线程--->" + i);
}
}
}
class MyThread extends Thread{
@Override
public void run() {
//编写程序，这段程序运行在分支线程中(分支栈)
for (int i = 0; i < 10; i++) {
System.out.println("分支线程---->" + i);
}
}
}
运行结果：
2.2 run和start的区别
run方法的示意图：
start方法的示意图：
2. 3 实现线程的第二种方式
package 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 < 10; i++) {
System.out.println("主线程--->" + i);
}
}
}
//这并不是一个线程类，是一个可运行的类，它还不是一个线程
class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("分支线程--->" + i);
}
}
}
运行结果：
2.4 采用匿名内部类实现线程
package 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 < 10; i++) {
System.out.println("t线程--->" + i);
}
}
});
//启动线程
t.start();
for (int i = 0; i < 10; i++) {
System.out.println("main线程--->" + i);
}
}
}
运行结果：
3.线程生命周期
4.获取线程信息
-
获取线程对象的名字： String name = 线程对象.getName()；
-
修改线程对象的名字：线程对象.setName(“线程名字”)；
-
当线程没有设置名字的时候，默认名字为：Thread-0，Thread-1，Thread-2…
-
获取当前线程对象：static Thread currentThread()
Thread t = Thread.currentThread();
演示代码：
package thread;
public class ThreadTest05 {
public void doSome(){
//这样不行
//this.getName;
//super.getName;
//这样可以
String name = Thread.currentThread().getName();
System.out.println("----->" + name);
}
public static void main(String[] args) {
ThreadTest05 tt = new ThreadTest05();
tt.doSome();
//currentThread就是当前线程对象
//这个代码出现在main方法当中，所以当前线程就是主线程
Thread currentThread = Thread.currentThread();
System.out.println(currentThread.getName());//输出为：main
//创建线程对象
MyThread2 t1 = new MyThread2();
//设置线程的名字
t1.setName("t1");
//获取线程的名字 默认名字为Thread-0
String tName = t1.getName();
System.out.println(tName);
//启动线程
t1.start();
MyThread2 t2 = new MyThread2();
t2.setName("t2");
System.out.println(t2.getName());
t2.start();
}
}
class MyThread2 extends Thread{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
//currentThread就是当前线程
//当t1线程执行run方法，那么这个当前线程就是t1
//当t2线程执行run方法，那么这个当前线程就是t2
Thread currentThread = Thread.currentThread();
System.out.println(currentThread.getName() + "-->" + i);
//super this也可以 因为当前类碰巧是线程类
//System.out.println(super.getName() + "-->" + i);
//System.out.println(this.getName() + "-->" + i);
}
}
}
运行结果：
5.线程的sleep方法
关于线程的sleep方法：static void sleep(long millis)
- 静态方法：Thread.sleep(1000)
- 参数是毫秒
- 作用：让当前线程进入休眠，进入“阻塞状态”，放弃占有CPU时间片，让给其它线程使用
例如：这行代码出现在A线程中，A线程就会进入休眠；这行代码出现在B线程中，B线程就会进入休眠 - Thread.sleep()方法，可以做到这种效果：间隔特定的时间，去执行一段特定的代码，每隔多久执行一次
实例代码一：
package thread;
public class ThreadTest06 {
public static void main(String[] args) {
//让当前线程进入休眠，睡眠5秒
//当前线程是主线程
try {
Thread.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}
//五秒之后执行这里的代码
System.out.println("hello world!");
}
}
实例代码二：
package thread;
public class ThreadTest06 {
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.1 面试题
下面代码会让线程t进入休眠状态吗？
package thread;
public class ThreadTest07 {
public static void main(String[] args) {
//创建线程对象
Thread t = new MyThread3();
t.setName("t");
t.start();
//调用sleep方法
try {
//在执行下面的代码的时候还是会转换成：Thread.sleep(1000 * 5)
//下面代码的作用是：让当前线程进入休眠，也就是说main线程进入休眠
//下面代码出现在main方法中，main线程睡眠
t.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}
//5秒之后这里才会执行
System.out.println("hello world!");
}
}
class MyThread3 extends Thread{
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
System.out.println(Thread.currentThread().getName() + "--->" + i);
}
}
}
答：不会！
5.2 终止线程的睡眠
sleep睡眠太久了，如果希望半道上醒来， 应该怎么办？也就是说怎么叫醒一个正在睡眠的线程？
注意：这个不是终断线程的执行，是终止线程的睡眠
package thread;
public class ThreadTest08 {
public static void main(String[] args) {
Thread t = new Thread(new MyRunnable2());
t.setName("t");
t.start();
//希望5秒之后，t线程醒来（5秒之后主线程手里的活儿干完了）
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 {
Thread.sleep(1000 * 60 * 60 * 24 * 365);
} catch (InterruptedException e) {
//打印异常信息
e.printStackTrace();
}
//1年之后才会执行这里
System.out.println(Thread.currentThread().getName() + "--->end");
//调用doOther
// try {
// doOther();
// } catch (Exception e) {
// e.printStackTrace();
// }
}
//其他方法可以throws
// private void doOther() throws Exception{
// }
}
运行结果：
5.3 强行终止线程的执行
stop()方式存在很大的缺点：容易丢失数据，因为这种方式是直接将线程杀死了，线程没有保存的数据将会丢失，不建议使用
package thread;
public class ThreadTest09 {
public static void main(String[] args) {
Thread t = new Thread(new MyRunnalbe3());
t.setName("t");
t.start();
//模拟5秒
try {
Thread.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}
//5秒之后强行终止t线程
t.stop();//已过时（不建议使用）
}
}
class MyRunnalbe3 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();
}
}
}
}
运行结果：
5.4 合理终止线程的执行
package thread;
public class ThreadTest10 {
public static void main(String[] args) {
MyRunnalbe4 r = new MyRunnalbe4();
Thread t = new Thread(r);
t.setName("t");
t.start();
//模拟5秒
try {
Thread.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}
//终止线程
//你想要什么时候终止t的执行，那么你把标记修改为false，就结束了
r.run = false;
}
}
class MyRunnalbe4 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;
}
}
}
}
6.线程调度
6.1 概述
常见的线程调度模型：
| 线程调度模型 | 备注 |
|---|---|
| 抢占式调度模型 | 那个线程的优先级比较高，抢到的CPU时间片的概率就高一些/多一些，java采用的就是抢占式调度模型 |
| 均分式调度模型 | 平均分配CPU时间片，每个线程占有的CPU时间片时间长度一样，平均分配，一切平等【有一些编程语言，线程调度模型采用的式这种方式】 |
java中提供了和线程调度有关的方法：
| 方法 | 类别 | 概念 |
|---|---|---|
| void setPriority(int newPriority) | 实例方法 | 设置线程的优先级 |
| int getPriority( ) | 实例方法 | 获取线程优先级 |
| static void yield() | 静态方法 | 让位方法 |
| void join() | 实例方法 | 合并线程 |
6.2 线程优先级
实例方法：
void setPriority(int newPriority)设置线程的优先级
int getPriority( ) 获取线程优先级
最低优先级1
默认优先级是5
最高优先级10
优先级比较高的获取CPU时间片可能会多一些（但也不完全是，大概率是多的）
package thread;
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
//获取当前线程对象，获取当前线程的优先级
Thread currentThread = Thread.currentThread();
System.out.println(currentThread.getName() + "线程的默认优先级是：" + currentThread.getPriority());//输出为：main线程的默认优先级是：5
Thread t = new Thread(new MyRunnable5());
t.setName("t");
t.start();
}
}
class MyRunnable5 implements Runnable{
@Override
public void run() {
//获取线程优先级
System.out.println(Thread.currentThread().getName() + "线程的默认优先级是：" + Thread.currentThread().getPriority());
}
}
运行结果：
package thread;
public class ThreadTest11 {
public static void main(String[] args) {
//设置主线程的优先级为1
Thread.currentThread().setPriority(1);
Thread t = new Thread(new MyRunnable5());
t.setPriority(10);
t.setName("t");
t.start();
//优先级较高的，只是抢到的CPU时间片相对多一些
//大概率方向更偏向于优先级比较高的
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}
class MyRunnable5 implements Runnable{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}
运行结果：
6.3 线程让位
静态方法：
static void yield() 让位方法
暂停当前正在执行的线程对象，并执行其他线程
yield()方法不是阻塞方法，让当前线程让位，让给其它线程使用
yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”
注意：在回到就绪之后，有可能还会再次抢到
package thread;
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);
}
}
}
运行结果：
6.4 线程合并
实例方法：
void join()
合并线程
class MyThread1 extends Thread{
public void doSome(){
MyThread2 t = new MyThread2();
t.join();//当前线程进入阻塞，t线程执行，直到t线程结束，当前线程才可以继续
}
}
class MyThread2 extends Thread{
}
package 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 < 10; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}
运行结果：
7.线程安全
以后在开发中，我们的项目都是运行在服务器当中，而服务器已经将线程的定义，线程对象的创建，线程的启动等等，都已经实现完了，这些代码我们都不需要编写
注意：程序员要知道，自己编写的程序需要放到一个多线程的环境下运行，更需要关注的是这些数据在多线程并发的环境下是否是安全的。
7.1 线程不安全条件
下面时刻数据在多线程并发的环境下会存在安全问题：
- 条件1：多线程并发
- 条件2：有共享数据
- 条件3：共享数据有修改的行为
满足以上3个条件之后，就会存在线程安全问题
7.2 解决线程安全问题
当多线程并发的环境下，有共享数据，并且这个数据还会被修改，此时就存在线程安全问题
解决方案：线程排队执行（不能并发）
用排队执行解决线程安全问题，这种机制被称为：线程同步机制【专业术语：线程同步，实际上就是线程不能并发了，线程必须排队执行】
备注：线程同步就是线程排队，线程排队了就会牺牲一部分效率，没办法，数据安全第一位，只有数据安全了，才可以谈效率，数据不安全，就没有效率的事了
7.3 同步和异步
异步编程模型：
线程t1和线程t2，各自执行各自的，t1不管t2，t2不管t1，谁也不需要等谁【其实就是：多线程并发(效率较高)】
同步编程模型：
线程t1和线程t2，在线程t1执行的时候，必须等待t2线程执行结束，或者说在t2线程执行的时候，必须等待t1线程执行结束，两个线程之间发生了等待关系，这就是同步编程模型，效率较低，线程排队执行
总结：异步就是并发，同步就是排队
7.4 编程模拟（不使用线程同步机制）
不使用线程同步机制，多线程对同一个账户进行取款，出现线程安全问题
编写程序模拟两个线程同时对同一个账户进行取款操作
银行账户：
package 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;
//在这里模拟一下网络延迟，100%会出问题
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//更新余额
//t1执行到这里，但还没有来得及执行这行代码，t2线程进来withdraw方法了，此时一定出问题
this.setBalance(after);
}
}
账户线程：
package threadsafe;
public class AccountThread extends Thread{
//两个线程必须共享同一个账户对象
private Account act;
//通过构造方法传递过来账户对象
public AccountThread(Account act) {
this.act = act;
}
@Override
public void run() {
//run方法的执行表示取款操作
//假设取款5000
double money = 5000;
//取款
//多线程并发执行这个方法
act.withdraw(money);
System.out.println(Thread.currentThread().getName() + "对" + act.getActno() + "取款" + money +"成功，余额" + act.getBalance());
}
}
测试类：
package threadsafe;
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();
}
}
运行结果：
7.5 编程模拟（使用线程同步机制）
使用线程同步机制，解决线程安全问题
- 线程同步机制语法：
synchronized (){
//线程同步代码块
}
- synchronized()后面小括号中传的这个“数据”是相当关键的，这个数据必须是多线程共享的数据，才能达到多线程排队
- ()中写什么？
那要看程序员想让哪些线程同步。
假设t1、t2、t3、t4、t5，有5个线程，只希望t1、t2、t3排队，t4、t5不需要排队
程序员一定要在()中写一个t1、t2、t3共享的对象，而这个对象对于t4、t5来说不是共享的
银行线程和测试类不变
银行账户：
package 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){
//以下这几行代码必须是线程排队的，不能并发
//一个线程把这里的代码全部执行结束之后，另一个线程才能进来
//这里的共享对象是：账户对象
//账户对象是共享的，那么this就是账户对象
//不一定是this，这里只要是多线程共享的那个对象就行
//最好使用this，因为this会灵活的变动
synchronized (this){
double before = this.getBalance();
double after = before - money;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setBalance(after);
}
}
}
7.6 synchronized理解
在java语言中，任何一个对象都有“―把锁”，其实这把锁就是标记。(只是把它叫做锁)
100个对象，100把锁。1个对象1把锁。
以下代码的执行原理?
synchronized (this){
double before = this.getBalance();
double after = before - money;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setBalance(after);
}
1、假设t1和t2线程并发，开始执行以下代码的时候，肯定有一个先一个后。
2、假设t1先执行了，遇到了synchronized，这个时候自动找"后面共享对象"的对象锁，找到之后，并占有这把锁，然后执行同步代码块中的程序，在程序执行过程中一直都是占有这把锁的。直到同步代码块代码结束，这把锁才会释放。
3、假设t1已经占有这把锁，此时t2也遇到synchronized关键字，也会去占有后面共享对象的这把锁，结果这把锁被t1占有，t2只能在同步代码块外面等待t1的结束，直到t1把同步代码块执行结束了，t1会归还这把锁，此时t2终于等到这把锁，然后t2占有这把锁之后,进入同步代码块执行程序。
4、这样就达到了线程排队执行
注意：这个共享对象一定要选好，这个共享对象一定是你需要排队执行的这些线程对象所共享的
7.7 编程模拟
银行线程和测试类不变
银行账户变形一：
定义全局对象
package threadsafe2;
public class Account {
//账号
private String actno;
//余额
private double balance;
//对象
Object obj = new Object();//实例变量(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 (obj){
double before = this.getBalance();
double after = before - money;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setBalance(after);
}
}
}
总结：此时也可以达到this一样的效果
银行账户变形二：
定义局部对象
package 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){
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);
}
}
}
运行结果：
总结：局部变量定义的对象就不符合要求
银行账户变形三：
定义常量对象，因为"abc"在字符串常量池中
此时所有的线程都会同步，例如t1、t2、t3、t4、t5都会同步
package 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 ("abc"){
double before = this.getBalance();
double after = before - money;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setBalance(after);
}
}
}
7.8 有线程安全问题的变量
Java中的三大变量：
- 实例变量：在堆中
- 静态变量：在方法区中
- 局部变量：在栈中
- 局部变量永远不会存在线程安全问题，因为局部变量在栈中(一个线程一个栈)，所以局部变量永远都不会共享
- 实例变量在堆中，堆只有1个；静态变量在方法区中，方法区也只有1个；堆和方法区都是多线程共享的，所以可能存在线程安全问题
- 局部变量+常量：不会有线程安全问题
- 成员变量【实例变量+静态变量】：可能会有线程安全问题
7.9 扩大同步范围
同步代码块越小效率越高
测试类不变，将银行账户中的同步放到银行线程中
package threadsafe2;
public class AccountThread extends Thread{
//两个线程必须共享同一个账户对象
private Account act;
//通过构造方法传递过来账户对象
public AccountThread(Account act) {
this.act = act;
}
@Override
public void run() {
//run方法的执行表示取款操作
//假设取款5000
double money = 5000;
//取款
//多线程并发执行这个方法
synchronized(act){
act.withdraw(money);//这种方式也可以，只不过扩大了同步的范围，效率更低了
}
System.out.println(Thread.currentThread().getName() + "对" + act.getActno() + "取款" + money +"成功，余额" + act.getBalance());
}
}
7.10 synchronized出现在实例方法上
在实例方法上可以使用synchronized
缺点：
- 但是一定锁的是this，不能是其它的对象，这种方式不灵活
- synchronized出现在实例方法上，表示整个方法体都需要同步，可能会无故扩大同步的范围，导致程序的执行效率降低，所以这种方式不常用
优点：
- 代码写的少了，节俭了
注意：如果共享的对象是this，并且需要同步的代码块是整个方法，建议使用这种方式
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，而StringBuffer效率比较低
| 属性 | 是否非线程安全 |
|---|---|
| ArrayList | 非线程安全 |
| Vector | 线程安全 |
| HashMap/HashSet | 非线程安全 |
| Hashtable | 线程安全 |
7.10 synchronized总结
synchronized有三种写法：
- 同步代码块：灵活
synchronized(线程共享对象){
同步代码块;
}
- 在实例方法上使用synchronized，表示共享对象一定是this，并且同步代码块是整个方法体
- 在静态方法上使用synchronized，表示找类锁，类锁永远只有1把，就算创建了100个对象，那类锁也只有一把
注意：
- 对象锁：1个对象1把锁，100个对象100把锁
- 类锁：100个对象，也可能只是1把类锁
8.synchronized面试题
8.1 面试题一
问题：下面代码中：doOther方法执行的时候需要等待doSome方法的结束吗
答：不需要，因为doOther方法没有synchronized
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;
}
@Override
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");
}
}
8.2 面试题二
问题：下面代码中：doOther方法执行的时候需要等待doSome方法的结束吗
答：需要，因为doOther方法也有synchronized
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;
}
@Override
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 synchronized void doOther(){
System.out.println("doOther begin");
System.out.println("doOther over");
}
}
8.3 面试题三
问题：下面代码中：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;
}
@Override
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 synchronized void doOther(){
System.out.println("doOther begin");
System.out.println("doOther over");
}
}
8.4 面试题四
问题：下面代码中：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;
}
@Override
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");
}
}