一、什么是进程和线程：
——进程：是一个应用程序（一个进程是一个软件）。
——线程：是一个进程中的执行场景 / 执行单元。
注：一个进程可以启动多个线程。
二、进程和线程的关系：
——进程可以看做是现实生活当中的火车站。
——线程可以看做是火车站当中的售票窗口。
注：
进程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 ThreadcurrentThread()：获得当前正在执行的线程对象的引用。voidsetName(String name)：改变线程名称。StringgetName()：获得该线程的名称。static voidsleep(long millis)： 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）。voidinterrupt()：中断线程的睡眠。- 终止一个线程的执行
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中和线程调度有关的方法：
- 设置和获取线程调度优先级（实例方法）
voidsetPriority(int newPriority)：设置线程的优先级。intgetPriority()：获取线程优先级。
最低优先级是1，默认优先级是5，最高优先级是10
——优先级比较高的获取CPU时间片可能会多一些。（但也不完全是，大概率是多的。）
- 让位方法（静态方法）
static voidyield()：暂停当前正在执行的线程对象，并执行其他线程。
yield()方法不是阻塞方法。
是让当前线程让位，让给其它线程使用。
yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”。
注：在回到就绪之后，有可能还会再次抢到CPU时间片。
- 合并线程（实例方法）
voidjoin()：等待该线程终止（类似合并后插队）。
class MyThread1 extends Thread { public void doSome(){ MyThread2 t = new MyThread2(); t.join(); // 当前线程进入阻塞，t线程执行，直到t线程结束。当前线程才可以继续。 } } class MyThread2 extends Thread{ }
- 设置和获取线程调度优先级（实例方法）
3112
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
