- java中常使用多线程进行并发编程
- 1.重写Thread类的run方法创建线程
- 2.创建一个类继承Runnable接口并将其实例传给Thread实例
- 3./4.使用匿名内部类
- 5.lambda(第四种的延伸):使用lambd代替Runnable
- 线程的状态getState()
- NEW: 安排了工作, 还未开始行动
- RUNNABLE: 可工作的. 又可以分成正在工作中和即将开始工作.
- BLOCKED: 这几个都表示排队等着其他事情
- WAITING: 这几个都表示排队等着其他事情
- TIMED_WAITING: 这几个都表示排队等着其他事情
- TERMINATED: 工作完成了.
- 多线程可以提高任务完成效率(有时不能)
- Thread常见构造方法
- Thread类的其他属性和方法
- 线程的创建/线程的终止/线程的等待/线程获取引用/线程的休眠
- 启动一个线程-start()
- 终断线程Thread.currentThread().isInterrupted()
- 线程等待join()
- Thread.crurendThread()那个线程调用,就获取到谁的实例
- 线程的休眠sleep
操作系统中提供了一组关于线程的C语言风格的API,java对其进一步封装,就成了Thread类
java标准库中提供了Thread类,来表示和操作线程,可以视为java标准库提供的API.
一个进程中至少有一个线程
1.重写Thread类的run方法创建线程重写的run方法中描述了线程要执行的代码,每个线程都是并发执行,因此要告诉这个线程要执行的代码是什么,在run方法中只是在安排要执行的工作,并没有实施.
package thread;
class MyThread2 extends Thread {
@Override
public void run() {
while (true) {
System.out.println("hello thread!");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class Demo2 {
public static void main(String[] args) {
Thread t = new MyThread2();
t.start();
while (true) {
System.out.println("hello main");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
创建Thread实例时,就已经吧任务创建好了,t.start()正式开始执行
这里调用的start方法才是真正在系统中创建了线程并开始执行run方法,在调用start之前系统是没有创建出线程的,这是在同一个进程中创建线程,
自己创建的t线程和自动创建的main线程,就是并发关系:
此处的并发=并行+并发.宏观上是区分不了并行和并发的.都取决于系统内部的调度~
注意:
sleep这个事情到了ms级并不是那么精确的!!!
sleep 1000不是说正好1000ms之后就上cpu,意思1000之内你上不了cpu, sleep 1000写了之后,可能是1006才上的cpu
sleep 1001写了之后,可能是1002就上了cpu~~
输出如下:
现在两个线程,都是打印一条,就休眠个1s~当1s 时间到了之后,系统先唤醒谁呢?看起来这个顺序不是完全确定(随机的)
每一轮,1s 时间到了之后,到底是先唤醒main还是 thread,这是不确定的(随机的)
操作系统来说,内部对于线程之间的调度顺序,在宏观上可以认为是随机的(抢占式执行)
通过Runnable来描述任务内容,并将其交给Thread实例
// Runnable 就是在描述一个 "任务"
class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("hello");
}
}
public class Demo3 {
public static void main(String[] args) {
Thread t = new Thread(new MyRunnable());
t.start();
}
}
3./4.使用匿名内部类
通常认为Runnable这种写法跟好一点,更好的解耦
Runnable单纯的只是描述了一个任务~至于这个任务是要通过一个进程来执行,还是线程来执行,还是线程池来执行,还是协程来执行,Runnable本身并不关心.Runnable 里面的代码也不关心.
public class Demo4 {
public static void main(String[] args) {
Thread t = new Thread() {
@Override
public void run() {
System.out.println("hello thread");
}
};
t.start();
}
}
public class Demo5 {
public static void main(String[] args) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("hello thread");
}
});
t.start();
}
}
5.lambda(第四种的延伸):使用lambd代替Runnable
public class Demo6 {
public static void main(String[] args) {
Thread t = new Thread(() -> {
System.out.println("hello thread");
});
t.start();
}
}
线程的状态getState()
NEW: 安排了工作, 还未开始行动
已经创建好了Thread对象,但还没有调用 start
public class Demo14 {
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(() -> {
while (true) {
});
System.out.println(t.getState());
t.start();
}
}
java内部状态,和操作系统中PCB里的状态没啥关系
RUNNABLE: 可工作的. 又可以分成正在工作中和即将开始工作.就绪状态:处于这个状态的线程,就是在就绪队列中.随时可以被调度到CPU 上
如果代码中没有进行sleep,也没有进行其他的可能导致阻塞的操作代码大概率是处在Runnable状态的
public class Demo14 {
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(() -> {
while (true) {
}
});
t.start();
Thread.sleep(1000);
System.out.println(t.getState());
}
}
BLOCKED: 这几个都表示排队等着其他事情
当前线程在等待锁,导致了阻塞(阻塞状态之一)
synchronized
当前线程在等待唤醒,导致了阻塞(阻塞状态之一)wait
TIMED_WAITING: 这几个都表示排队等着其他事情代码中调用了 sleep,就会进入到TIMED_WAITINGjoin(超时时间)
意思就是当前的线程在一定时间之内,是阻塞的状态
public class Demo14 {
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(() -> {
while (true) {
// 这里啥都不能有!!!
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t.start();
Thread.sleep(1000);
System.out.println(t.getState());
}
}
TERMINATED: 工作完成了.
public class Demo14 {
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(() -> {
while (true) {
// 这里啥都不能有!!!
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t.start();
Thread.sleep(1000);
System.out.println(t.getState());
}
}
操作系统中的线程已经执行完毕,销毁了,但是Thread对象还在
java内部状态,和操作系统中PCB里的状态没啥关系
多线程特别适合于那种CPU密集型的程序.
程序要进行大量的计算,使用多线程就可以更充分的利用CPU的多核资源~~
也可以使用jconsole观察线程名字
getId():ID 是线程的唯一标识,不同线程不会重复
getName():名称是各种调试工具用到
getState():状态表示线程当前所处的一个情况,下面我们会进一步说明
getPriority():优先级高的线程理论上来说更容易被调度到
isDaemon():关于后台线程,需要记住一点:JVM会在一个进程的所有非后台线程结束后,才会结束运行。如果线程是后台线程,就不影响进程退出.如果线程不是后台线程(前台线程),就会影响到进程退出心~创建的t1和t2默认都是前台的线程,即使main方法执行完毕,进程也不能退出.得等t1和t2都执行完,整个进程才能退出!!!如果t1和t2是后台线程此时如果main执行完毕,整个进程就直接退出, t1和t2就被强行终止了
isAlive():是否存活,即简单的理解,为 run 方法是否运行结束了
isInterrupted():线程的中断问题
线程的创建/线程的终止/线程的等待/线程获取引用/线程的休眠 启动一个线程-start()决定系统是不是真的创建出线程
start和run的区别:
run只是一个普通的方法,描述了任务的内容,在main线程中调用run并没有创建新的线程
public class Demo9 {
public static void main(String[] args) {
Thread t = new Thread(() -> {
for (int i = 0; i < 5; i++) {
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
// t.start();
t.run();
while (true) {
System.out.println("hello main");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
终断线程Thread.currentThread().isInterrupted()
核心思路是让线程中的run方法执行完
Thread.interrupted():这是一个静态方法
Thread.crurentThread.isInterrupted():这是实例方法,其中currentThread能够获取到当前线程的实例
区别:
Thread.interrupted()这个方法判定的标志位是Thread的static成员.(一个程序中只有一个标志位)
Thread.currentThread().isInterrupted(这个方法判定的标志位是Thread的普通成员.每个示例都有自己的标志位.一般无脑使用这个
public class Demo11 {
public static void main(String[] args) {
Thread t = new Thread(() -> {
while (!Thread.currentThread().isInterrupted()) {
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
// 当触发异常之后, 立即就退出循环~
System.out.println("这是收尾工作");
break;
}
}
});
t.start();
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 在主线程中, 调用 interrupt 方法, 来中断这个线程.
// t.interrupt 的意思就是让 t 线程被中断!!
t.interrupt();
}
}
调用t.interrupt()会产生两种情况:
1.如果t线程是就绪状态,调用后线程的标志位(Thread.currentThread().isInterrupted())变为true
2.如果t线程处在阻塞状态(sleep休眠),就会触发一个InterruptException异常,而此代码一旦触发异常后,进入catch中后,仅单纯打印一个日志,然后继续执行,没有起到终止线程的作用,所以在上述代码中的catch中加入break来跳出循环
线程等待join()线程之间的调度是无序的,需要控制线程的执行顺序,线程等待是其中一种手段
public class Demo12 {
public static void main(String[] args) {
Thread t = new Thread(() -> {
for (int i = 0; i < 5; i++) {
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t.start();
// 在主线程中就可以使用一个等待操作. 来等待 t 线程执行结束.
try {
t.join(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
t.join() 调用者等待被调用者,等待被调用者执行完毕后,再继续往下执行
但是 join() 默认情况下是死等,(不合理)
可以用 join(ms) 时间之内被调用线程结束直接返回,超过时间也直接返回
进程, PCB+双向链表这个说法是针对只有一个线程的进程,是如此的
如果是一个进程有多个线程, 此时每个线程都有一个PCB,一个进程对应的就是一组PCB 了
PCB上有一个字段tgroupld,这个id 其实就相当于进程的id.同一个进程中的若干个线程的tgroupld是相同的!!!
process control block是进程控制块?和线程有啥关系?其实 Linux内核不区分进程和线程.进程线程是程序猿写应用程序代码,搞出来的词.实际上Linux内核只认PCB !!!在内核里Linux把线程称为轻量级进程
PCB上有一个字段 tgroupld,这个id其实就相当于进程的id.同一个进程中的若干个线程的 tgroupld是相同的!!!
PCB上有一个字段 tgroupld,这个id其实就相当于进程的id.同一个进程中的若干个线程的 tgroupld是相同的!!!



