一、什么是进程和线程:
——进程:是一个应用程序(一个进程是一个软件)。
——线程:是一个进程中的执行场景 / 执行单元。
注:一个进程可以启动多个线程。
二、进程和线程的关系:
——进程可以看做是现实生活当中的火车站。
——线程可以看做是火车站当中的售票窗口。
注:
进程A和进程B的内存独立不共享(资源不会共享)。
线程A和线程B的堆内存和方法区内存共享,但是栈内存独立,一个线程一个栈。
三、实现线程的方式:
- 第一种方式:编写一个类,直接继承java.lang.Thread,重写run()方法。
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("主线程--->" + i); } } } class MyThread extends Thread { @Override public void run() { // 编写程序,这段程序运行在分支线程中(分支栈)。 for(int i = 0; i < 1000; i++){ System.out.println("分支线程--->" + i); } } }
- java支持多线程机制。并且java已经将多线程实现了,我们只需要继承就行了。
- t.run() 和 t.start() 的区别:
- t.run():不会启动线程,不会分配新的分支栈(线程),只相当于调用了 t 对象中的run()方法。
- t.start():启动一个分支线程,在JVM中开辟一个新的栈空间,这段代码任务完成之后,瞬间就结束了。
——这段代码的任务只是为了开启一个新的栈空间,只要新的栈空间开出来,start()方法就结束了。线程就启动成功了。
- t.run():不会启动线程,不会分配新的分支栈(线程),只相当于调用了 t 对象中的run()方法。
- 第二种方式:编写一个类实现java.lang.Runnable接口,重写run()方法。
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 < 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); } } }
public class ThreadTest03 { public static void main(String[] args) { //匿名内部类 Thread t = new Thread(new Runnable() { @Override public void run() { for (int i = 0; i < 100; i++) { System.out.println("分支线程:" + i); } } }); t.start(); for (int i = 0; i < 100; i++) { System.out.println("主线程:" + i); } } }
- 第三种方式:实现Callable接口。(JDK8新特性)
import java.util.concurrent.Callable; import java.util.concurrent.FutureTask; // JUC包下的,属于java的并发包,老JDK中没有这个包。新特性。 public class ThreadTest15 { public static void main(String[] args) throws Exception { // 第一步:创建一个“未来任务类”对象。 // 参数非常重要,需要给一个Callable接口实现类对象。 FutureTask task = new FutureTask(new Callable() { @Override public Object call() throws Exception { // call()方法就相当于run方法。只不过这个有返回值 // 线程执行一个任务,执行之后可能会有一个执行结果 // 模拟执行 System.out.println("call method begin"); Thread.sleep(1000 * 10); System.out.println("call method end!"); int a = 100; int b = 200; return a + b; //自动装箱(300结果变成Integer) } }); // 创建线程对象 Thread t = new Thread(task); // 启动线程 t.start(); // 这里是main方法,这是在主线程中。 // 在主线程中,怎么获取t线程的返回结果? // get()方法的执行会导致“当前线程阻塞” Object obj = task.get(); System.out.println("线程执行结果:" + obj); // main方法这里的程序要想执行必须等待get()方法的结束 // 而get()方法可能需要很久。因为get()方法是为了拿另一个线程的执行结果 // 另一个线程执行是需要时间的。 System.out.println("hello world!"); } }
- 实现Callable接口,这种方式实现的线程可以获取线程的返回值。
—— 优点:可以获取到线程的执行结果。
—— 缺点:在获取t线程执行结果的时候,当前线程受阻塞,效率较低。
- 实现Callable接口,这种方式实现的线程可以获取线程的返回值。
四、线程对象的生命周期
- 新建状态:刚new出来的线程对象。
- 就绪状态(可运行状态):表示当前线程具有抢夺CPU时间片的权利(CPU时间片就是执行权)。
- 运行状态:当一个线程抢夺到执行权后,就开始执行run方法,run方法的开始执行标志着线程进入运行状态。
- 阻塞状态:当一个线程遇到阻塞事件(例:接收用户键盘输入、sleep方法等),线程会进入阻塞状态。
- 死亡状态:线程结束。
五、线程常用的方法
static Thread
currentThread():获得当前正在执行的线程对象的引用。void
setName(String name):改变线程名称。String
getName():获得该线程的名称。static void
sleep(long millis): 在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)。void
interrupt():中断线程的睡眠。- 终止一个线程的执行
public class ThreadTest04 { public static void main(String[] args) { MyRunnable1 myRunnable1 = new MyRunnable1(); Thread thread = new Thread(myRunnable1,"thread 1"); thread.start(); //模拟thread 1线程睡眠5秒后终止睡眠(主线程暂停5秒) try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } //终止线程睡眠 thread.interrupt(); //再让主线程睡眠5秒(模拟thread 1线程运行5秒后强行终止运行) try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } //终止thread 1线程 //你想要什么时候终止thread 1的执行,那么你把标记修改为false,就结束了。 myRunnable1.run = false; } } class MyRunnable1 implements Runnable { //设置一个布尔标记 boolean run = true; @Override public void run() { System.out.println(Thread.currentThread().getName()+"--->"+"睡眠开始"); //当前线程睡眠1小时后继续执行 try { Thread.sleep(1000 * 60 * 60); } catch (InterruptedException e) { } System.out.println(Thread.currentThread().getName() + "--->" + "睡眠结束"); 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.... //终止线程 System.out.println(Thread.currentThread().getName()+"线程强行终止成功!"); return; } } } }
六、线程调度
- 常见的线程调度模型有哪些?
- 抢占式调度模型:哪个线程的优先级比较高,抢到的CPU时间片的概率就高一些(多一些)。
——java采用的就是抢占式调度模型 - 均分式调度模型:平均分配CPU时间片。每个线程占有的CPU时间片时间长度一样。
- 抢占式调度模型:哪个线程的优先级比较高,抢到的CPU时间片的概率就高一些(多一些)。
- Java中和线程调度有关的方法:
- 设置和获取线程调度优先级(实例方法)
void
setPriority(int newPriority):设置线程的优先级。int
getPriority():获取线程优先级。
最低优先级是1,默认优先级是5,最高优先级是10
——优先级比较高的获取CPU时间片可能会多一些。(但也不完全是,大概率是多的。)
- 让位方法(静态方法)
static void
yield():暂停当前正在执行的线程对象,并执行其他线程。
yield()方法不是阻塞方法。
是让当前线程让位,让给其它线程使用。
yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”。
注:在回到就绪之后,有可能还会再次抢到CPU时间片。
- 合并线程(实例方法)
void
join():等待该线程终止(类似合并后插队)。
class MyThread1 extends Thread { public void doSome(){ MyThread2 t = new MyThread2(); t.join(); // 当前线程进入阻塞,t线程执行,直到t线程结束。当前线程才可以继续。 } } class MyThread2 extends Thread{ }
- 设置和获取线程调度优先级(实例方法)