文章目录
1.进程与线程
-
说起进程,就不得不说程序。程序是指令和数据的有序集合,它本身只是一个静态的概念。没有运行的含义
-
而进程是执行程序的一次执行过程,它是一个动态的概念。进程是系统分配资源的单位
-
通常一个进程包含若干个线程,至少包含一条线程,否则没有存在的意义。线程是CPU执行和调度的单位
注意:
很多的多线程是模拟出来的,真正的多线程是指有多个CPU同时跑多个线程。当只有一个CPU时,在同一时间,CPU只能执行一个代码,也就是一条线程,只是线程之间的切换比较快,人一般难以察觉,会误以为是同时进行
2.线程创建的方式
1.继承Thread类
(1)继承Thread类
(2)重写 run() 方法
(3)调用 start() 方法启动线程
// 不建议使用,避免oop单继承局限性
// 线程开启不一定执行,由CPU调度执行
// 创建线程方法一:继承Thread类,重写run()方法,调用start()开启线程
public class TestThread1 extends Thread{ // 1、继承Thread类
@Override
public void run() { // 2、重写run()方法
//run()方法线程体
for (int i = 0; i < 2000; i++) {
System.out.println("我在学习多线程" + i);
}
}
public static void main(String[] args) {
// main方法,主线程
// 创建一个线程对象
TestThread1 testThread1 = new TestThread1();
// 3、调用start()开启线程
testThread1.start();
for (int i = 0; i < 2000; i++) {
System.out.println("我在看书" + i);
}
}
}
执行结果是我在看书和我在学习多线程交替执行的。至于执行顺序是什么是由CPU调度执行的
2.实现Runnable接口(推荐)
(1)实现Runnable接口
(2)重写 run() 方法
(3)创建一个线程对象,将线程对象传入Thread实例(对象)中
(4)Thread对象调用start()方法启动线程
// 推荐使用,避免单继承局限性,灵活方便,方便同一个对象被多个线程调用
// 创建线程方法二:实现Runnable接口,重写run()方法,执行线程需要丢入Runnable接口实现类,调用start()方法
public class TestThread2 implements Runnable{ // 1、实现Runnable接口
@Override
public void run() { // 2、重写run()方法
//run()方法线程体
for (int i = 0; i < 2000; i++) {
System.out.println("我在学习多线程"+i);
}
}
public static void main(String[] args) {
// main方法,主线程
// 3.1、创建一个线程对象
TestThread2 t2 = new TestThread2();
// 3.2、丢入Runnable接口实现类
Thread thread = new Thread(t2);
// 4、调用start()开启线程
thread.start();
for (int i = 0; i < 2000; i++) {
System.out.println("我在看书"+i);
}
}
}
3.实现Callable接口
(1)实现Callable接口,需要返回值
(2)重写call() 方法,需要抛出异常
(3)创建目标对象
(4)将目标对象传入FutureTask构造器生成FutureTask实例化对象
(5)将FutureTask实例对象传入Thread,生成Thread对象
(6)Thread对象调用start()开启线程
注意:使用此方法创建线程可以通过get()方法可以获取返回值,需抛出异常
/**
* 创建线程方法三:实现Callable接口,重写call()方法,
* 创建目标对象传入FutureTask构造器生成FutureTask对象
* 将FutureTask对象传入Thread类生成Thread对象,调用start()方法开启线程
*
* 注意:使用此方法创建线程可以通过get()方法可以获取返回值,需抛出异常
*/
public class TestThread3 implements Callable { // 1、实现Callable接口
@Override
public String call() throws Exception { // 2、重写call()方法,需抛出异常,有返回值
for (int i = 0; i < 2000; i++) {
System.out.println("我在学习多线程" + i);
}
return "线程已执行";
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
// main方法,主线程
// 3、创建一个目标对象
TestThread3 t3 = new TestThread3();
// 4、将目标对象传入FutureTask构造器生成FutureTask实例化对象
FutureTask<String> futureTask = new FutureTask<String>(t3);
// 5、将FutureTask实例对象传入Thread,生成Thread对象
Thread thread = new Thread(futureTask);
// 6、调用start()开启线程
thread.start();
// 通过get()方法可以获取返回值,需抛出异常
String str = futureTask.get();
System.out.println("str = " + str);
}
}
4.Lambda表达式
(1)在Thread构造器中传入Lambda表达式生成Thread对象
(2)调用start()方法启动线程
// 线程创建方法四:Lambda表达式,在Thread构造器中传入Lambda表达式生成Thread对象,调用start()方法启动线程
public class TestThread4 {
public static void main(String[] args) {
// 1、传入Lambda表达式
Thread thread = new Thread(()->{
for (int i = 0; i < 2000; i++) {
System.out.println("我在学习多线程" + i);
}
});
// 2、调用start()方法启动线程
thread.start();
for (int i = 0; i < 2000; i++) {
System.out.println("我在看书" + i);
}
}
}
实质上,Runnable接口就是一个函数式接口,所以这其实属于实现Runnable接口实现线程的方式,只是将方法体直接写在Thread构造参数里
3.线程的状态
来自狂神视频的图片
1、新建状态(new):当使用new Thread()新建一条线程时,此时线程并未启动,只是出于新建状态
2、就绪状态(Runnable):当使用了start()方法时,此时线程进入就绪状态,但并不会立即执行run()方法里的代码,而是等待CPU的调度
3、运行状态(Running):当线程获得CPU分配的资源时开始运行,此时才会执行run()方法里的代码
4、阻塞状态(Blocked):当线程在运行过程中可能由于各种原因进入阻塞状态,例如调用sleep(),wait()方法等,此时线程会进入阻塞状态,暂时让出CPU资源,其它就绪状态的线程就可以抢夺资源运行线程,进入阻塞状态的资源要想运行,也要先进入就绪状态,等待CPU调度才能再次运行
5、死亡状态(Dead):线程进入死亡状态有两种方式,一个是执行完run()里面的代码,第二个是遇到异常提前结束。要想知道线程是否是死亡状态,可以使用isAlive()方法判断,如果是就绪、运行或者阻塞状态会返回true,处于new和死亡状态会返回false
4.线程的一些方法
1、sleep()
-
sleep(时间),指定当前线程阻塞的毫秒数,例如sleep(3000)表示当前线程阻塞3000毫秒;
-
sleep存在异常状态InterruptedException,需抛出异常;
-
sleep时间到达后线程进入就绪状态;
-
sleep可以模拟网网络延时,倒计时等;
-
再有锁的情况下,sleep不会释放锁;
小问题:sleep(0)有什么用?
sleep(0)表示睡眠0毫秒,乍看一下没有什么用,但是线程确实是被挂起了一瞬间,此时,线程会让出自己的CPU资源,进入阻塞状态,让其他线程去抢夺,也就是有机会先执行,其实它也就是起到一个礼让的作用
2、yield()
-
礼让线程,让当前正在执行的线程暂停,但不阻塞;
-
将线程运行状态转为就绪状态;
-
让CPU重新调度,礼让不一定成功,看CPU如何调度;
/**
* 测试你让线程
* 礼让不一定成功,看CPU如何调度
*/
public class TestYield {
public static void main(String[] args) {
MyYield myYield = new MyYield();
new Thread(myYield,"a").start();
new Thread(myYield,"b").start();
}
}
class MyYield implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程开始运行!");
Thread.yield();
System.out.println(Thread.currentThread().getName()+"线程结束运行!");
}
}
3、join()
-
join合并线程,等到这个线程执行完后其他线程才可以执行,其他线程阻塞;
-
其实就是强制插队
/**
* 测试join
*/
public class TestJoin implements Runnable{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("vip线程来了!"+i);
}
}
public static void main(String[] args) throws InterruptedException {
TestJoin testJoin = new TestJoin();
Thread thread = new Thread(testJoin);
thread.start();
for (int i = 0; i < 1000; i++) {
if(i==200){
thread.join(); // 插队
}
System.out.println("main线程"+i);
}
}
}