共计 13749 个字符,预计需要花费 35 分钟才能阅读完成。
多线程
1. 什么是过程?
一个程序的运行期间就是过程,多个程序运行及时多过程。
多过程有什么作用?
多过程的作用不是进步执行速度,而是进步 CPU 的使用率。过程与过程之间是独立的。** 什么是线程?**
线程是过程的一个执行场景,一个过程能够启动多个线程。
多线程有什么作用
多线程不是为了进步执行速度,而是进步应用程序的使用率。
线程和线程共享“堆内存和办法区内存”,栈内存是独立的,意思就是一个线程一个栈。
会给人类一个错觉,认为多个线程是在同时并发运行。
多线程的创立与应用
多线程创立与应用有两种形式。
多线程创立的第一种形式:
应用分为三步
- 定义线程,继承 java.long.Thread 类,重写 run 办法
- 创立线程,new 类,调用 Thread 中的 start()办法
- 启动线程。
多线程创立的第二种形式
应用分为三步
- 定义线程,履行 Runable 接口,实现 run 办法
- 创立线程,调用 Thread 类中的构造方法,new Thread(Runable runable); 调用 start()办法
- 运行线程
上代码
线程的第一种闯将形式:
@java
public class ThreadTest01{public static void main(String[] args){Thread thread = new Realize01();
thread.start();}
}
class Realize01 exteads Thread{public void run(){for(int i = 0;i < 10;i++){System.out.println("run-->" + i);
}
}
}
线程的第二种创立形式:
@java
public class ThreadTest02{public static void main(String[] args){Thread thread = new Thread(new Realize02);
thread.start();}
}
class Realize02 implements Runable{public void run(){for(int i = 0;i < 10;i++){System.out.println("run-->" + i);
}
}
}
多线程的生命周期
- 新建:采纳 new 语句创立实现
- 就绪:执行 start()之后示意就绪状态,就绪状态的线程示意有权力争取 CPU 的工夫片,谁先争取到工夫片,谁就先运行。
- 运行:占用了 CPU 的工夫片(就绪状态中线程或取到的工夫片取决于你运行的工夫,退出你在工夫片的范畴内没有把代码运行完,那么这个线程会从新到就绪状态,争取 CPU 的工夫片,再次进入到运行状态中会接着上次没有执行完的代码接着执行),执行 run 办法。
- 阻塞:执行了 wait 语句、执行了 sleep 语句和期待某个对象锁,期待输出的场景
- 完结:run 办法完结。
线程的调度与管制
Java 虚拟机要负责线程的调度,获得 CPU 的使用权,目前有两种调度模式;分时调度模式:所有线程轮流是用 CPU 的使用权,平均分配每个线程占用 CPU 的工夫片。抢占试调度模式:优先让优先级高的线程应用 CPU,如果线程的优先级雷同,那么会随机抉择一个,优先级高的 CPU 抢占的工夫片会绝对多一点。
线程的优先级:
-
线程的优先级分为三个
- 最大的为 10(MAX_PRIORITY)
- 最小的为 1(MIN_PRIORITY)
- 默认的为 5(NORM_PRIORITY)
线程的优先级取决于线程的执行程序
Thread.currentThread;获取线程以后的援用。
getName();获取以后的线程名称
setName();设置以后的线程名称
setPriority();设置线程优先级
public class ThreadTest02 {public static void <u>main(String[] </u><u>args</u><u>)</u> {Thread t1 = new Realize();
// 设置本线程的线程名字
t1.setName("t1");
// 设置线程的优先级
t1.setPriority(6);
Thread t2 = new Realize();
t2.setName("t2");
t2.setPriority(7);
t1.start();
t2.start();}
}
class Realize extends Thread{
@Override
public void run() {for (int i = 0; i < 10; i++) {System.out.println(Thread.currentThread().getName() + "-----" + i);
}
}
}
这行代码的运行后果 t2 的运行工夫是大于 t1 的,也就是 t2 的工夫片大于 t1
线程的进行与中断
Thread.sleep(int time); 在指定的毫秒数内让以后正在执行的线程休眠(暂停执行),此操作受到零碎计时器和调度程序精度和准确性的影响。
void join(); 期待该线程终止。在线程中插入执行另一个线程, 该线程被阻塞,直到插入执行的线程齐全执行毕当前,该线程才继续执行上来.
Thread.yield; 暂停以后正在执行的线程对象,并执行其余线程。
void interrupt(); 字面意思是中断的意思,但在 java 中,是通过某种形式去告诉线程,而不是中断线程。
@java
public static void main(String[] args) throws Exception {
// 字线程
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {for (int i = 0; i < 10; i++) {System.out.println(i);
}
}
});
t1.start();
// t1.join();// 主线程的执行权让个 t1
Thread.yield();// 暂停主线程,执行 t1 线程
for (int i = 0; i < 10; i++) {Thread.sleep(1000);
System.out.println("Hello Word!");
}
}
这里运次后果是 t1 线程执行,而后每隔一秒执行一次主线程。退出不把 join 给正文掉,线程的执行权就会让给 t1。
当线程在睡眠期间如何被中断
@java
public class ThreadTest06 {public static void main(String[] args) throws Exception {Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
try {Thread.sleep(10000000000000l);
System.out.println("Hello World!");
} catch (InterruptedException e) {System.out.println("线程在睡眠中被吵醒了!");
e.printStackTrace();}
for (int i = 0; i < 5; i++) {System.out.println(i);
}
}
});
t2.start();
Thread.sleep(5000);
t2.interrupt();}
}
如何正确的终止线程
每次循环的时候都判断一下 a,如果是 true 就睡眠,如果是 false 就执行输入语句
@java
public static void main(String[] args) throws Exception {Realize07 t = new Realize07();
Thread tt = new Thread(t);
tt.start();
Thread.sleep(500);
t.a = false;
}
}
class Realize07 implements Runnable{
boolean a = true;
@Override
public void run() {for (int i = 0; i < 10; i++) {if (a){
try {Thread.sleep(1000);
} catch (InterruptedException e) {e.printStackTrace();
}
}else{System.out.println("线程被中断了!");
}
}
}
线程的同步和锁机制
1. 异步线程
- 两个线程同时执行,没有先后顺序,java 个别都是异步执行,然而有时候在某些条件下,必须应用同步线 程。
2. 同步线程
- 同步线程就是 t1 线程执行完而后执行 t2 线程
- 执行条件就是必须在多线程环境下,两个线程共享同一块数据的时候,对这块数据进行删改操作。
上代码
@java
/*
* <u> 定义一个账户,对这个账户进行取钱。* 定义两个线程同时进行操作
*/
public class ThreadTest01 {public static void main(String[] args) throws Exception{Account act = new Account("account-01",5000);
Thread t1 = new Thread(new Realize(act));
Thread t2= new Thread(new Realize(act));
t1.start();
t2.start();}
}
class Account{
private String name;// 账户名
private double money;// 账户余额
public Account(){}
public Account(String name,double money){
this.name = name ;
this.money = money;
}
public String getName() {return name;}
public void setName(String name) {this.name = name;}
public double getMoney() {return money;}
public void setMoney(double money) {this.money = money;}
/**
* 对账户进行取钱
*/
public void drawmoney(double draw){
double nowmoney = this.money - draw;
this.setMoney(nowmoney);
}
}
class Realize implements Runnable{
Account act;
public Realize(){}
public Realize(Account act){this.act = act;}
@Override
public void run() {act.drawmoney(1000.0);
try{Thread.sleep(1000);
}catch(Exception e){}
System.out.println(act.getName() + "取走 1000 元胜利, 余额:"+act.getMoney());
}
}
运行后果:
@java
account-01 取走 1000 元胜利, 余额:4000.0
account-01 取走 1000 元胜利, 余额:4000.0
Process finished with exit code 0
两个线程同时拜访了一个操作,t1 线程还没有执行完的时候,t2 线程就曾经获取到余额是 4000。t2 不会等 t1 执行完在去执行。退出取款机是这样的操作,这是守法的。须要等 t1 线程执行完再去执行 t2 线程,其实同步线程有很多种办法,效率最高的就是 synchronized。
3. synchronized(锁对象){执行的要同步的代码}
这里对 run 办法中公共执行的代码进行了加锁,谁先找到对象锁,那个线程就先执行,这两个线程的数据是共享的,所以对象锁只有一个。
synchronized 也能够当做加载办法中。
这个默认的也是 this。
两者的区别:
- synchronized(锁对象){执行的要同步的代码}跟应用在办法中的成果一样,不过有些时候你无奈保障你 run 办法外面的代码都是公共的,所以一般来说,synchronized(){}效率更高。
当你拜访两个线程时,一个线程调用的办法加锁了,另一个线程调用的办法没有加锁,同时执行时,没有加锁的会不会受加锁的影响呢?
@java
public class ThreadTest02 {public static void main(String[] args) throws Exception {Realize02 rl = new Realize02();
T1 t = new T1(rl);
Thread t1 = new Thread(t);
t1.setName("t1");
Thread t2 = new Thread(t);
t2.setName("t2");
t1.start();
// 保障 T1 先执行
Thread.sleep(1000);
t2.start();}
}
class T1 implements Runnable{
Realize02 rl;
public T1(Realize02 rl) {this.rl = rl;}
public T1(){}
@Override
public void run() {if (Thread.currentThread().getName().equals("t1")){rl.m1();
}
if (Thread.currentThread().getName().equals("t2")){rl.m2();
}
}
}
class Realize02{public synchronized void m1(){
try {Thread.sleep(5000);
} catch (InterruptedException e) {e.printStackTrace();
}
System.out.println("m1.....");
}
public void m2(){System.out.println("m2.......");
}
}
运行后果:
@java
m2.......
m1.....
能够看到,只管在 t1 线程执行完让主线程休眠 1s 之后在再执行 t2 线程,然而 m2 办法并没有等 m1 办法休眠过后再执行,而是间接执行。
退出 m2 办法也加 synchronize, 那么 m2 会等 m1 先执行完后才执行, 因为两个线程应用的是一个对象锁。谁先拿到谁就先执行。
@java
public synchronized void m2(){System.out.println("m2.......");
}
如果两个线程应用的不是同一个对象锁,那么 m2 办法同样不会受到 m1 办法的影响,在 t2 拿到就间接执行。
类锁
- 如果你要增加的锁的办法不是成员办法,而是静态方法,那么这个锁指向的就不是对象锁而是 类锁。
- 类锁只有一个。
@java
public class ThreadTest02 {public static void main(String[] args) throws Exception {Realize02 rl1 = new Realize02();
Realize02 rl2 = new Realize02();
T1 t = new T1(rl1);
T1 tt = new T1(rl2);
Thread t1 = new Thread(t);
t1.setName("t1");
Thread t2 = new Thread(tt);
t2.setName("t2");
t1.start();
// 保障 T1 先执行
Thread.sleep(1000);
t2.start();}
}
class T1 implements Runnable{
Realize02 rl;
public T1(Realize02 rl) {this.rl = rl;}
public T1(){}
@Override
public void run() {if (Thread.currentThread().getName().equals("t1")){<u>rl</u><u>.</u><u>m1</u><u>()</u>;
}
if (Thread.currentThread().getName().equals("t2")){<u>rl</u><u>.</u><u>m2</u><u>()</u>;
}
}
}
class Realize02{public synchronized static void <u>m1()</u>{
try {Thread.sleep(5000);
} catch (InterruptedException e) {e.printStackTrace();
}
System.out.println("m1.....");
}
/**
* 在 m2 也增加办法锁 synchronize 会等到 m1 执行完之后才执行,因为两个对象应用的是同一个对象锁
*/
public synchronized static void <u>m2()</u>{System.out.println("m2.......");
}
}
运行后果是,m2 先等 m1 执行完而后才执行,只管两个应用的不是同一个对象。起因就是因为不论你是用的是不是同一个对象,只有是这个类的,那么类锁就只有一个,谁先拿到就执行谁。
死锁
当线程 A 锁住 a 的同时又想锁住 b,线程 B 想锁住 b 的同时又想锁住 a,这样“你要拿我,我要拿你就叫做死锁”
@java
public class ThreadTest03 {public static void <u>main(String[] </u><u>args</u><u>)</u> {Object o1 = new Object();
Object o2 = new Object();
Thread t1 = new Thread(new T2(o1,o2));
Thread t2 = new Thread(new T3(o1,o2));
t1.start();
t2.start();}
}
class <u>T2</u> implements Runnable{
Object o1;
Object o2;
public T2(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){}}
}
}
class T3 implements Runnable{
Object o1;
Object o2;
public T3(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){}}
}
}
t2 线程先锁住 o1 而后去锁 o2,t3 线程先锁住 o2 而后去锁 o1。o1,o2 为两个人的共享数据。
守护线程
java 线程分为守护线程和非守护线程。非守护线程又叫做用户线程,咱们平时编写的一些线程就叫做用户线程。
守护线程会在所有的用户线程完结才会主动完结。
Java 在运行的时候调动 JVM,JVM 是一个过程,外面有多个线程,JC(垃圾回收器)就是守护线程,它会在所有的用户过程完结完而后主动退出程序。
java 吧线程设置守护线程的办法:在 start 之前调用 strDaemon(true)办法。
- setDaemon(true) 必须在 start() 之前设置,否则会抛出 IllegalThreadStateException 异样,该线程仍默认为用户线程,继续执行
- 守护线程创立的线程也是守护线程
- 守护线程不应该拜访、写入长久化资源,如文件、数据库,因为它会在任何工夫被进行,导致资源未开释、数据写入中断等问题
@java
public class TreadTest01 {public static void main(String[] args) {Thread t1 = new Thread(new on());
// 设置该线程为守护线程
t1.setDaemon(true);
t1.start();
// 主线程须要执行的代码
for (int i = 0; i < 10; i++) {System.out.println(Thread.currentThread().getName() +
"----" + i);
try {Thread.sleep(500);
} catch (InterruptedException e) {e.printStackTrace();
}
}
}
}
class on implements Runnable{
@Override
public void run() {
int i = 0;
while(true){
try {Thread.sleep(1000);
} catch (InterruptedException e) {e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"----"+i);
i++;
}
}
}
运行后果
main----0
main----1
main----2
Thread-0----0
main----3
Thread-0----1
main----4
main----5
Thread-0----2
main----6
main----7
Thread-0----3
main----8
main----9
Thread-0----4
Process finished with exit code 0
只管 t 线程外面的执行的是死循环,然而应用了 setDaeon()办法转换为守护线程之后,在所有的用户线程执行完之后,主动 break(完结)。
定时器(Timer 类)
Timer 类的作用是设置打算工作,然而工作封装的类是 TimerTask 类。执行打算工作的代码要放入 TimerTask 的子类中,因而 TimerTask 是一个抽象类。
schedule(TimerTask task,Date time)办法 在指定的日期执行某一件事
@java
class Task02 extends <u>TimerTask</u>{
@Override
public void <u>run()</u> {System.out.println("Just I miss you!");
}
}
实现类
@java
import java.text.SimpleDateFormat;
import java.util.Timer;
import java.util.TimerTask;
public class <u>TimerTest02</u> {public static void main(String[] args) throws Exception {Timer tmr = new Timer();
tmr.schedule(new <u>Task02</u>(), new SimpleDateFormat("yyyy-MM-dd
HH:mm:ss").parse("2020-10-6 13:04:00"));
}
}
运行后果
@java
Just I miss you!
Process finished with exit code -1
schedule(TimerTask task,Date time,long period); 激活从什么工夫开始,每隔多长时间,执行一次工作
@java
class Task extends <u>TimerTask</u> {
@Override
public void <u>run()</u> {System.out.println(Calendar.getInstance().getTime().toLocaleString());
}
}
测试类
@java
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Timer;
import java.util.TimerTask;
public class <u>TimerTest01</u> {public static void main(String[] args) throws Exception {
//1. 创立定时器
Timer tmr = new Timer();
tmr.schedule(new <u>Task</u>(),new SimpleDateFormat("yyyy-MM-dd
HH:mm:ss").parse("2020-10-6 13:07:00"),10*1000);
}
}
运行后果: 每隔 10 秒钟就输入一次工夫!
@java
2020-10-6 13:07:02
2020-10-6 13:07:12
2020-10-6 13:07:22