JavaSE进阶 - 多线程
1、基本概念
什么是进程?
进程是一个应用程序(1个进程是一个软件)。
什么是线程?
线程是一个进程中的执行场景/执行单元,一个进程可以启动多个线程。
对于Java程序来说,当在DOS命令窗口中输入:
java HelloWorld 回车之后
会先启动JVM,而JVM就是一个进程,JVM在启动一个主线程调用main方法,同时在启动一个垃圾回收器线程负责看护,回收垃圾。一个是垃圾回收器线程、一个是执行main方法的主线程。
进程和线程之间是什么关系?
阿里巴巴:进程
马云:阿里巴巴的一个线程
童文红:阿里巴巴的一个线程
进程可以看做是现实生活当中的公司,线程可以看做是公司当中的某个员工。
注意:
进程A和进程B的内存独立不共享(即两个进程之间的内存不共享)。
在Java语言中:线程A和线程B,堆内存和方法区内存共享,但是栈内存独立,一个线程一个栈。假设启动10个线程,就会有10个栈空间,每一个栈和栈之间互不干扰,各自执行各自的,这就是多线程并发。
如:火车站可以看做四一个进程。
在火车站中的每一个售票窗口可以看做是一个线程。我在窗口1购票,你可以在窗口2购票,我们两个都不需要互相等对方,所有多线程并发可以提供效率。
Java中之所以有多线程机制,目的就是为了提供程序的处理效率。
思考一个问题:
使用了多线程机制之后,main()方法结束,是不是有可能程序也不会结束,main()方法结束只是主线程结束了,主栈空了,其他的栈(进程)可能还在压栈弹栈。
分析一个问题:对于单核的CPU来说,真的可以做到真正的多线程并发?
对于多核的CPU来说,真正的多线程并发是没有问题的。4核CPU表示同一个时间点上,可以真正的有4个进程并发执行。
什么是真正的多线程并发?
t1线程执行t1的。
t2线程执行t2的。
他们两个并不会互相干扰,这叫做真正的多线程并发。
单核的CPU表示只有一个大脑:不能够做到真正的多线程编发,但是可以做到给人一个“多线程并发”的感觉。对于单核的CPU来说,在某个时间点上实际上只能处理一件事情,但是由于CPU的处理数独极快,多个线程之间“频繁切换”执行,给人的感觉就是:多个事情同时在做!
电影院采用胶卷播放电影,一个胶卷一个胶卷播放发速度达到一定的程度之后,人类的眼睛产生了错觉,感觉是动画的。在这个期间计算机可以进行亿万次的循环,因为计算机的执行速度很快。
package com.zh0u.javase.thread;
/*
分析以下程序有几个线程,除垃圾回收器之外。有几个线程?
答案:只有一个线程(因为程序只有一个“栈”)。注:一个“方法”不等于一个“栈”。
main begin!
m1 begin!
m2 begin!
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 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!");
}
}
2、多线程的实现
2.1、方法一:继承Thread
package com.zh0u.javase.thread;
/*
实现线程的第一种方式:
编写一个类,直接继承java.lang.Thread并重写其中的run()方法。
怎么创建线程对象?new就可以了。
怎么启动线程?调用线程对象的start()方法。
注意:
亘古不变的规定:方法题当中的代码永远都是自上而下的顺序依次逐行执行。
以下程序的输出结果有这样的特点:
有先有后、有多有少。
这是咋回事?这里先画一个问号?
*/
public class ThreadTest02 {
public static void main(String[] args) {
// 这里是main()方法,这里的代码属于主线程,在主栈中运行。
// 新建一个分支线程对象
MyThread t = new MyThread();
// 启动线程
// t.run(); // 不会启动线程,不会分配新得分支栈(这种方式就是单线程)。
/*
start()方法的作用是:启动一个分支线程,在JVM中开辟一个新的占空间,这段代码任务完成之后,瞬间就结束了。
这段代码的任务只是为了开启一个新的栈空间,只要新的占空间开出来,start()方法立即就结束了,线程就启动成功了。
启动成功的线程会自动调用run()方法,并且run()方法在分支栈的栈底部(压栈)。
run()方法在分支栈的底部,main()方法在主栈的底部,run()和main()是平级的。
*/
t.start();
// 这里的代码还是运行在主线程中
for (int i = 0; i < 1000; i++) {
System.out.println("main ---> " + i);
}
}
}
// 自定义线程类
class MyThread extends Thread{
// 这里继承Thread的类必须重写run()方法
public void run() {
// 编写程序,这段程序运行在分支线程当中(分支栈)。
for (int i = 0; i < 1000; i++) {
System.out.println("myThread ---> "+i);
}
}
}
2.2、run与start
直接执行:
t.run();
myThread ---> 0
...
myThread ---> 990
myThread ---> 991
myThread ---> 992
myThread ---> 993
myThread ---> 994
myThread ---> 995
myThread ---> 996
myThread ---> 997
myThread ---> 998
myThread ---> 999
main ---> 0
main ---> 1
main ---> 2
main ---> 3
main ---> 4
main ---> 5
main ---> 6
main ---> 7
main ---> 8
main ---> 9
main ---> 10
...
main ---> 999
t.start();
main ---> 0
myThread ---> 0
myThread ---> 1
myThread ---> 2
myThread ---> 3
myThread ---> 4
myThread ---> 5
myThread ---> 6
main ---> 1
main ---> 2
main ---> 3
main ---> 4
myThread ---> 7
main ---> 5
myThread ---> 8
main ---> 6
myThread ---> 9
myThread ---> 10
myThread ---> 11
myThread ---> 12
main ---> 7
myThread ---> 13
main ---> 8
myThread ---> 14
main ---> 9
myThread ---> 15
main ---> 10
main ---> 11
main ---> 12
myThread ---> 16
main ---> 13
myThread ---> 17
main ---> 14
myThread ---> 18
main ---> 15
main ---> 16
myThread ---> 19
main ---> 17
main ---> 18
main ---> 19
myThread ---> 20
main ---> 20
myThread ---> 21
main ---> 21
myThread ---> 22
main ---> 22
myThread ---> 23
...
2.3、方法二:实现Runnable
package com.zh0u.javase.thread;
/*
实现多线程的第二种方法:实现Runnable接口
*/
public class ThreadTest03 {
public static void main(String[] args) {
// 创建一个可运行对象
// MyRunnable myRunnable = new MyRunnable();
// 将可运行的对象封装成一个线程对象
// Thread t = new Thread(myRunnable);
// 直接写成一句代码
Thread thread = new Thread(new MyRunnable());
// 启动线程
thread.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);
}
}
}
第二种方式实现接口比较常用,因为一个类实现了接口,它还可以去继承其他的类,更灵活。
2.4、采用匿名内部类实现
package com.zh0u.javase.thread;
/*
采用匿名内部类的形式实现。
*/
public class ThreadTest04 {
public static void main(String[] args) {
// 创建线程对象,采用匿名内部类的方式。
// 这是通过一个没有名字的类,new出来的对象。
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);
}
}
}
3、线程的生命周期
新建状态、就绪状态、运行状态、阻塞状态、死亡状态。
4、获取当前线程对象
package com.zh0u.javase.thread;
/*
1、怎么获取当前线程对象。
Thread t = Thread.currentThread();
返回值t即使当前线程。
2、获取线程对象的名字。
String name = 线程对象.getName();
3、修改线程对象的名字。
线程对象.setName("线程名字");
4、当线程没有设置名字的时候,默认的名字有什么规律?
Thread-0
Thread-1
Thread-2
Thread-3
……
*/
public class ThreadTest05 {
public static void main(String[] args) {
// currentThread就是当前线程对象
// 这个代码出现在main()方法当中,所以当前线程就是主线程
Thread currentThread = Thread.currentThread();
System.out.println(currentThread.getName()); // main
// 创建线程对象
MyThread2 thread2 = new MyThread2();
/*
// 设置线程的名字
thread2.setName("robots1");
// 获取线程的名字
System.out.println(thread2.getName()); // robots1
*/
// 以下使用线程的默认名称
String thread2Name = thread2.getName();
System.out.println(thread2Name); // Thread-0
MyThread2 thread21 = new MyThread2();
System.out.println(thread21.getName()); // Thread-1
// 启动线程
thread2.start();
thread21.start();
}
}
class MyThread2 extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
// currentThread就是当前线程对象。当前对象是谁呢?
// 当Thread-0线程执行run()方法时,那么这个当前线程就是Thread-0
// 当Thread-1线程执行run()方法时,那么这个当前线程就是Thread-1
Thread currentThread = Thread.currentThread();
System.out.println(currentThread.getName() + " ---> " + i);
}
}
}
5、sleep()
package com.zh0u.javase.thread;
/*
关于线程的sleep()方法:
public static void sleep(long millis) throws InterruptedException
1、静态方法:Thread.sleep(1000);
2、参数是毫秒
3、作用:让“当前线程”进入休眠,进入“阻塞状态”,放弃占有CPU的时间片,让给其他线程使用。
这行代码出现在A线程中,A线程就会进入休眠。
这行代码出现在B线程中,B线程就会进入休眠。
4、Thread.sleep()方法,可以做到这种效果:
间隔特定的时间,去执行一段特定的代码,每隔多久执行一次。
*/
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);
// 睡眠 1 秒
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
5.1、唤醒sleep中的线程
package com.zh0u.javase.thread;
import java.awt.print.PrinterException;
/*
sleep()方法睡眠时间太长了,如果希望半道醒来,应该咋样做?
注意:这个不是中断线程的执行,是终止线程的睡眠。
*/
public class ThreadTest08 {
public static void main(String[] args) {
Thread t = new Thread(new MyThread4());
t.setName("t");
t.start();
// 希望5秒之后,t线程醒来(5秒钟之后主线程手里的活儿干完了)。
try {
Thread.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 终止t线程的睡眠(这种中断睡眠的方式依靠了Java的异常处理机制)。
t.interrupt(); //直接唤醒
}
}
class MyThread4 implements Runnable{
/*
重点:run()当中的异常不能throws,只能try catch。
因为run()方法在父类中没有抛出任何异常,子类不能比父类抛出更多的异常。
*/
@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!");
}
}
5.2、sleep()面试题:
package com.zh0u.javase.thread;
/*
关于Thread.sleep()方法的一个面试题。
*/
public class ThreadTest07 {
public static void main(String[] args) {
// 创建线程对象
Thread thread3 = new MyThread3();
thread3.setName("t");
thread3.start();
// 调用sleep()方法
try {
// 问题:这行代码会让线程thread3进入休眠状态吗?
/*
答案:
在执行的时候还是会转换成:Thread.sleep(1000*5);(因为sleep是静态方法)
这行代码的作用是:让当前线程进入休眠,也就是说main线程进入休眠。
这行代码出现在main方法当中,main线程睡眠。
所以:下面的hello world会在5秒之后再输出。
*/
thread3.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}
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);
}
}
}
6、终止线程的两种方法
6.1、stop()方法
package com.zh0u.javase.thread;
/*
在Java中怎么强行终止一个线程的执行:
这种方式存在很大缺点:容易丢失数据。因为这种方式是直接将线程杀死了,线程中
没有保存的数据将会丢失。不建议使用。
*/
public class ThreadTest09 {
public static void main(String[] args) {
Thread t = new Thread(new MyThread5());
t.setName("t");
t.start();
// 模拟5秒
try {
Thread.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 5秒之后强行终止t线程
t.stop(); // 已过时(不建议使用)
}
}
class MyThread5 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();
}
}
}
}
6.2、Boolean判断(推荐)
package com.zh0u.javase.thread;
/*
合理终止一个线程执行的方式,这种方法很常用。
*/
public class ThreadTest10 {
public static void main(String[] args) {
MyRunnable1 r = new MyRunnable1();
Thread t = new Thread(r);
t.setName("t");
t.start();
// 模拟5秒
try {
Thread.sleep(1000 * 5);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 终止线程
// 想要什么时候终止t的执行,那么吧标志改成false就可以了。
r.flag = false;
}
}
class MyRunnable1 implements Runnable{
// 打一个Boolean标记
boolean flag = true;
@Override
public void run() {
for (int i = 0; i < 10; i++) {
if (flag) {
System.out.println(Thread.currentThread().getName() + "->" + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
// return就结束了,在结束之前还有什么没有保存的,在这里可以保存。
// save...
// 终止当前线程
return;
}
}
}
}
7、线程调度(了解)
7.1、常见的线程调度模型
**抢占式调度模型:**那个线程的优先级比较高,抢到的CPU时间片的概率就高一些/多一些。Java采用的就是抢占式调度模型。
**均分式调度模型:**平均分配CPU时间片,每个线程占有的CPU时间片的时间长度一样。有些编程语言线程调度模型采用的就是这种方式。
Java中提供的方法和线程调度有什么关系?
实例方法:
void setPriority(int newPriority); 设置线程的优先级
int getPriority(); 返回线程的优先级
最低优先级 1
默认优先级 5
最高优先级 10
优先级比较高的获取CPU时间片可能会多一些(但也不完全是,大概率是多的)。
静态方法:
static void yield(); 暂停当前正在执行的线程对象,并执行其他线程。
yield()方法不是阻塞方法,让当前线程让位,让给其他线程使用。
yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”。
注意:在回到就绪状态后,有可能还会再次抢到。
实例方法:
void join(); 合并线程。
class MyThread1 extends Thread {
public void doDome(){
MyThread2 t = new MyTread2();
// 当前线程进入阻塞,t线程执行,知道t线程结束,当前线程才可以继续执行。
t.join();
}
}
优先级:
package com.zh0u.javase.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()); // 5
// 创建MyRunnable2线程子类
Thread t = new Thread(new MyRunnable2());
// 设置t线程的优先级
// 优先级较高的,只是抢到的CPU时间片相对较多一些。即更偏向优先级较高的那个。
t.setPriority(10); // 设置为最高优先级
t.setName("t");
t.start();
for (int i = 0; i < 1000; i++) {
System.out.println(Thread.currentThread().getName() + "->" + i);
}
}
}
class MyRunnable2 implements Runnable{
@Override
public void run() {
// 输出:t线程的优先级5
// System.out.println(Thread.currentThread().getName() + "线程的优先级" + Thread.currentThread().getPriority());
for (int i = 0; i < 1000; i++) {
System.out.println(Thread.currentThread().getName() + "->" + i);
}
}
}
yield()方法:
package com.zh0u.javase.thread;
/*
yield()方法,当前线程让位。
*/
public class ThreadTest12 {
public static void main(String[] args) {
Thread t = new Thread(new MyRunnable4());
t.setName("thread");
t.start();
for (int i = 1; i <= 10000; i++) {
System.out.println(Thread.currentThread().getName() + "->" + i);
}
}
}
class MyRunnable4 implements Runnable{
int count = 0;
@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);
}
}
}
join()方法:
package com.zh0u.javase.thread;
/*
join()方法,阻塞当前线程。即线程合并。
*/
public class ThreadTest13 {
public static void main(String[] args) {
Thread thread = new Thread(new MyRunnable5());
thread.setName("t");
thread.start();
System.out.println(Thread.currentThread().getName()+" begin!");
// 使用join()方法将thread线程加入到当前main线程,当前线程(main)会被阻塞thread线程执行完毕之后才会执行main线程。
try {
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+" over!");
/*
输出:
main begin!
t->0
t->1
t->2
t->3
t->4
t->5
……
t->99
main over!
*/
}
}
class MyRunnable5 implements Runnable{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + "->" + i);
}
}
}
8、多线程安全(重点)* * * * *
为什么这个是重点?
以后在开发中,我们的项目都是运行在服务器当中,而服务器已经将线程的定义、线程对象的创建,线程的启动等都已经实现了。这些代码不需要我们编写。
最重要的是要知道,自己所编写的程序响应放到一个多线程的环境下运行,你更新于关注的是这些数据在多线程并发的环境下是否是安全的。
什么时候数据在多线程并发的环境下会存在安全问题?
如在银行取款问题:
线程安全问题的三个条件:
- 多线程并发;
- 有共享数据;
- 共享数据有修改的行为;
满足以上3个条件之后,就会存在线程安全问题。
怎么解决线程安全问题?
当多线程并发的华景下,有共享数据,并且这个数据还会被修改,此时就存在线程安全问题,怎么解决这个问题?
可以让线程“排队执行”(不能并发)。
用派对之星解决线程安全问题,这种机制被称为:线程同步机制。
专业术语叫做:线程同步,实际上就是线程不能并发了,线程必须排队执行。
怎么解决线程安全问题?
使用“线程同步机制”。
线程通过就是线程排队,线程排队了就会牺牲一部分效率,但是没有办法,数据安全第一位,只有数据安全了,才可以谈效率。如果数据不安全,就没有效率这一说。
线程通过与线程异步:
异步编程模型: -> 异步就是并发
线程t1和线程t2,各自执行各自的,t1不用管t2,t2不用管t1,谁也不需要等待谁,这种编程模型叫做:异步编程模型,其实就是“多线程并发(效率较高)”。
同步编程模型: - 同步就是排队
线程t1和线程t2,在t1线程执行之前,必须等待t2线程执行完毕,或者说在执行t2线程之前,必须等待t1线程完毕。两个线程之间发生了等待关系,这就是同步编程模型。
异步导致安全问题:
Account.java
package com.zh0u.javase.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.balance;
// 取款之后的余额
double after = before - money;
// 模拟网络延迟 1 秒钟,此时一定出现问题。
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 更新余额
// 思考:t1执行到这里了,但还没有来得及执行这行代码,t2线程进来执行withdraw()方法了,此时一定出现问题。
this.setBalance(after);
}
}
AccountThread.java
package com.zh0u.javase.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);
String message = Thread.currentThread().getName() + "对账户" + act.getActno() +
"取款"+money+"成功,余额为:" + act.getBalance();
System.out.println(message);
}
}
Test.java
package com.zh0u.javase.threadSafe;
public class Test {
public static void main(String[] args) {
// 创建账户对象(只创建一个)
Account act = new Account("act--001", 10000);
// 创建两个线程
AccountThread t1 = new AccountThread(act);
AccountThread t2 = new AccountThread(act);
// 设置线程名字
t1.setName("t1");
t2.setName("t2");
// 启动线程取款
t1.start();
t2.start();
}
}
8.1、synchronized关键字
使用synchronized关键字解决上面的问题:
// 取款
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,这里只要是多线程共享的那个对象就可以。
在Java语言中,任何一个对象都有“一把锁”,其实这把锁就是标记(只是把它叫做“锁”)。
1个对象一把锁,100个对象100把锁。
以下代码的执行原理:
1、假设t1和t2线程并发,开始执行以下代码的时候,肯定有一个先一个后。
2、假设t1先执行了,遇到synchronized关键字,这个时候自动找“后面共享对象”的对象锁,找到之后,并占有这把锁,然后执行同步代码块中的程序,在程序执行过程中一直都是占有这把锁的。直到同步代码块结束才会释放这把锁。
3、假设t1已经占有这把锁,此时t2也遇到synchronized关键字,也会去占有后面共享对象的这把锁,结果这把锁
被t1占用,t2只能在同步代码块外面等待t1的结束,直到t1把同步代码块中的所有代码都执行完毕了,t1才会归还这把锁,此时t2终于等到这把锁,然后t2占有这把锁之后,进入同步代码块执行程序。
这样就达到了线程排队执行。
这里需要注意的是:这个共享对象一定要选好,这个共享对象一定是需要排队执行的这些线程对象所共享的。
*/
// Object object = new Object();
// synchronized (antno){ // 这行代码也可以,因为antno为实例变量,是共享对象。
// synchronized (object){ // 这行代码就不行,object是局部变量,不是共享对象。
// synchronized ("abc") { // "abc"在字符串常量当中,这个也行,但是写这个的话,所有的线程都会同步(t1,t2,t3,t4,t5...)。
synchronized (this){
double before = this.balance;
double after = before - money;
// 模拟网络延迟 1 秒钟
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setBalance(after);
}
}
解决的第二种方式:
// 取款
/*
在实例方法上可以使用synchronized。
synchronized出现在实例方法上,一定锁的是this,不能是其他对象,所以这种方式不太灵活。
另外还有一点:synchronized出现在实例方法上,表示整个方法体都需要同步,可能会无故扩大同步的范围,导致程序执行效率降低。
所有这种方式不常用。
synchronized使用在还实例方法上有什么优点?
代码写的少。
如果共享对象是this,并且需要同步的代码块是整个方法体,建议使用这种方式。
*/
public synchronized void withdraw(double money){}
输出:
t1对账户act--001取款5000.0成功,余额为:5000.0
t2对账户act--001取款5000.0成功,余额为:0.0
8.2、synchronized的三种写法
synchronized的三种写法:
第一种:同步代码块,灵活
synchronized (线程共享对象){
同步代码块;
}
第二种:在实例方法上使用synchronized
表示共享对象一定是this,并且同步代码块是整个方法体。
第三种:在静态方法上使用synchronized,即可以使用类锁来保护“静态变量”的安全。
表示找“类锁”,类锁永远只有1把,就算创建了100个对象,那类锁也只有一把。
8.3、synchronized面试题
第一个:
package com.zh0u.javase.exam1;
/*
面试题:doOther()执行的时候不需要等待doSome()方法的结束吗?
答案:不需要,因为doOther()方法没有synchronized关键字修饰,执行的时候不需要共享对象执行锁。
*/
public class Exam01 {
public static void main(String[] args) {
MyClass mc = new MyClass();
MyThread t1 = new MyThread(mc);
MyThread t2 = new MyThread(mc);
t1.setName("t1");
t2.setName("t2");
t1.start();
// 这个睡眠的作用是为了保证t1先执行。
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
t2.start();
}
}
class MyThread extends Thread{
private final MyClass myClass;
public MyThread(MyClass myClass){
this.myClass = myClass;
}
@Override
public void run() {
if (Thread.currentThread().getName().equals("t1"))
myClass.doSome();
if (Thread.currentThread().getName().equals("t2"))
myClass.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!");
}
}
第二个:
package com.zh0u.javase.exam2;
/*
面试题:doOther()执行的时候不需要等待doSome()方法的结束吗?
答案:需要,因为synchronized修饰静态方法doSome()与doOther()方法,这里会执行一个类锁。
*/
class Exam02 {
public static void main(String[] args) {
MyClass mc1 = new MyClass();
MyClass mc2 = new MyClass();
MyThread t1 = new MyThread(mc1);
MyThread t2 = new MyThread(mc2);
t1.setName("t1");
t2.setName("t2");
t1.start();
// 这个睡眠的作用是为了保证t1先执行。
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
t2.start();
}
}
class MyThread extends Thread{
private final MyClass myClass;
public MyThread(MyClass myClass){
this.myClass = myClass;
}
@Override
public void run() {
if (Thread.currentThread().getName().equals("t1"))
MyClass.doSome();
if (Thread.currentThread().getName().equals("t2"))
MyClass.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!");
}
}
8.4、Java中的三大变量
实例变量 :在堆中。
静态变量 :在方法区。
局部变量 :在栈中。
以上三大变量中:
局部变量永远不会存在线程安全问题。因为局部变量不共享(一个线程一个栈),局部变量在占中,所有局部变量永远都不会共享。
实例变量在堆中,堆只有一个。静态变量在方法区中,方法区只有一个。堆和方法区都市多线程共享的,所以有可能存在线程安全问题。
如:在进行字符串拼接的时候,如果使用局部变量,建议使用StringBuilder,因为局部变量不存在线程安全问题。选择StringBuffer效率相对降低。
8.5、死锁
package com.zh0u.javase.deadLock;
/*
死锁代码要会写,一般面试官要求会写,只有会写,才会在以后的开发中重视这个事。
因为死锁很难调试。
synchronized在开发中最好不要嵌套使用,否则一不小心就好出现死锁这种情况。
*/
public class DeadLock {
public static void main(String[] args) {
Object o1 = new Object();
Object o2 = new Object();
// t1和t2两个线程共享o1,o2
MyThread1 t1 = new MyThread1(o1, o2);
MyThread2 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;
}
@Override
public void run() {
synchronized (o1){
// 让程序睡一秒钟
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (o2){
System.out.println("doSome!");
}
}
}
}
class MyThread2 extends Thread{
Object o1;
Object o2;
public MyThread2(Object o1, Object o2){
this.o1 = o1;
this.o2 = o2;
}
@Override
public void run() {
synchronized (o2){
// 让程序睡一秒钟
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (o1){
System.out.println("doSome!");
}
}
}
}
聊一聊以后在开发中怎么解决线程安全问题?
是一上来就选择线程同步吗?
不是,synchronized会让程序的执行效率降低,用户体验不好,系统的用户吞吐量降低。用户体验差。在不得已的情况下在选择线程同步机制。
第一种方案:尽量使用局部变量代替“实例变量”和“静态变量”。
第二种方案:如果必须使用实例变量,那么可以考虑创建多个对象,这样实例变量的内存就不共享了。(一个线程对应一个对象,100个线程对应100个对象,对象不共享,就没有数据的安全问题了)。
第三种方案:如果不能使用局部变量,对象也不能创建多个,这个时候就只能选择synchronized了。线程同步机制。
9、守护线程
Java语言中线程分为两大类:一类是用户线程,另一类是守护线程(后台线程)。其中守护线程具有代表性的就是“垃圾回收器”。
守护线程的特点:一般守护线程是一个死循环,所有的用户线程只要结束,守护线程自动结束。
注意:主线程main方法是一个用户线程。
package com.zh0u.javase.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();
}
}
}
}
10、定时器
定时器的作用:间隔特定的时间,执行特定的程序。
如:每周要进行银行账户的总账操作,每天要进行数据的备份操作。
在实际的开发中,每个多久执行一段特定的程序,这种需求是很常见的,那么在Java其实可以有多种实现的方式:
可以使用sleep方法睡眠,设置睡眠时间,每到这个时间点醒来,执行任务。这种方式是最原始的定时器(比较low)。
在Java的类库中已经写好了一个定时器:java.util.Timer,可以直接拿来用,不过,这种方式在目前的开发中也很少用,因为现在很多高级框架都是支持定时任务的。
在实际的开发中,目前使用较多的是Spring框架中提供的SpringTask框架(底层还是java.util.Timer),这个框架只要进行简单的配置就可以完成定时器的任务。
未完……