1. 认识线程
计算机的操作系统大多采用多用任务和分时设计
- 多任务：指在一个操作系统中可以同时运行多个程序
- 每个任务对应一个进程
- 每个进程又可以产生多个线程
（1）进程
- 程序是对数据描述与操作的代码的集合，进程是程序的一次动态执行过程
- 进程对应了从代码加载、执行至执行完毕的完整过程
- 该过程是进程从产生、发展至消亡的过程
- 特点：
- 进程是系统运行程序的基本单位
- 每一个进程都有自己的独立的一块内存空间
- 每一个进程的内部数据和状态都是完全独立的
（2）线程
- 线程是进程中执行运算的最小单位
- 一个进程在其执行过程中可以产生多个线程，而线程必须在某个进程内执行
- 线程是进程内部的一个执行单元，是可完成一个独立任务的顺序控制流程
- 一个进程中同时运行了多个线程，用来完成不同的工作，则称之为多线程
- 线程按处理级别可以分为核心级线程和用户级线程
- 核心级线程是和系统任务相关的线程
- 负责处理不同进程之间的多个线程
- 按照同一相对优先调度方法对线程进行调度
- 发挥并发优势
- 用户级线程
- 由于程序的需要而编写的线程
- 这些线程的创建、执行、消亡都是在编写应用程序时进行控制的
- 多线程可以改进用户体验，能更好的表达和解决显示世界的具体问题
- 核心级线程是和系统任务相关的线程
- 线程与进程的区别：
- 一个进程中至少有一个线程
- 资源分配给进程，同一进程的所有线程共享该进程的所有资源
- 处理机分配给线程，即真正在处理机上运行的是线程
（3）多线程的优势
- 可以带来更好的用户体验，避免因为程序执行过慢而导致计算机出现死机或者白屏的情况
- 可以最大限度地提高计算机系统地利用效率
2.编写线程类
- 每个程序至少自动拥有一个线程，称为主线程。当程序加载到内存时启动主线程
- Java 程序中 public static void main() 方法就是主线程的入口
- 使用一个线程的过程
- 定义一个线程，同时指明这个线程所要执行的代码，即期望完成的功能
- 继承 java.lang.Thread 类
- 实现 java.lang.Runnable 接口
- 创建线程对象
- 启动线程
- 终止线程
- 定义一个线程，同时指明这个线程所要执行的代码，即期望完成的功能
（1）使用 Thread 类创建线程
- Thread 类的常用方法
| 方法 | 说明 |
|---|---|
| void run() | 执行任务操作的方法 |
| void start() | 该线程开始执行 |
| void sleep(long millis) | 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行） |
| String getName() | 返回该线程的名称 |
| int getPriority() | 返回线程的优先级 |
| void setPriority(int newPriority) | 更改线程的优先级 |
| Thread.State getState() | 返回该线程的状态 |
| boolean isAlive() | 测试线程是否处于活动状态 |
| void join() | 等待该线程终止 |
| void interrupt() | 中断线程 |
| void yield() | 暂停当前正在执行的线程对象，并执行其他线程 |
- 创建线程时继承 Thread 类，并重写 Thread 类的 run() 方法
public class BhhThread extends Thread {
private int count=0;
//重写 run() 方法
public void run(){
while(count<10){
count++;
System.out.println("count的值是："+count);
}
}
}
public class ThreadTest{
public static void main(String[] args){
BhhThread bt=new BhhThread();
bt.start();
}
}
（2）使用 Runnable 接口创建线程
- Runnable 接口中声明了一个 run() 方法
- 即 pulic void run()
- 一个类可以通过实现 Runnable 接口并实现其 run() 方法完成线程的所有活动
- 已实现的 run() 方法称为该对象的线程体
- 任何实现 Runnable 接口的对象都可以作为一个线程的目标对象
- 示例
public class BhhThread implements Runnable{
private int count=0;
//实现 run() 方法
public void run(){
while(count<8){
count++;
System.out.println("count的值是："+count);
}
}
}
public class ThreadTest{
public static void main(String[] args){
Thread t=new Thread(new BhhThread());
t.start();
}
}
- 两种创建线程的方式各自有着各自的特点和应用领域
- 直接继承 Thread 类的方式编写简单
- 可以直接操作线程
- 适用于单重继承的情况
- 当一个线程继承了另一个类时，只能用实现 Runnable 接口的方式来创建线程
- 可以多个线程之间使用同一个 Runnable 对象
- 直接继承 Thread 类的方式编写简单
3.线程的状态
线程的生命周期可以分为4个阶段，即线程的4中状态
- 新生状态（New Thread）
- 创建线程对象之后，尚未调用其 start() 方法之前，这个线程就已经有了生命
- 此时线程仅仅是一个空对象，系统没有为其分配资源
- 此时只能启动和终止线程，任何其他操作都会引发异常
- 可运行状态
- 当调用 start() 方法启动线程后，系统为该线程分配除 CPU 以外的所需资源，就有了运行的机会
- 线程处于可运行的状态
- 可能正在运行，也可能尚未运行
- 对于只有一个 CPU 的机器而言，任何时刻只能有一个处于可运行状态线程占用处理机
- 此时系统真正运行线程的 run() 方法
- 阻塞状态
- 一个正在运行的线程因某种原因不能继续运行时，进入阻塞状态
- 是一种不可运行状态
- 处于这种状态的线程在得到一个待定的事件之后会转回可运行状态
- 导致一个线程被阻塞的原因如下：
- 调用了一个 Thread 类的静态方法 sleep()
- 一个线程执行到 I/O操作时，若I/O操作尚未完成，则线程将被阻塞
- 若一个线程的执行需要得到一个对象的锁，而锁正被别的线程占用，则线程被阻塞
- 线程的 suspend() 方法被调用而使线程被挂起时，线程进入阻塞状态
- 但 suspend() 方法容易导致死锁，已经被JDK 列为过期方法，基本不再使用
- 处于阻塞状态下的线程可以转回可运行状态
- 在调用 sleep() 方法后，线程的睡眠时间已经达到了指定的间隔，就转回可运行状态
- 当一个线程等待的锁变得可用的时候，也可转回可运行状态
- 死亡状态
- 一个线程的 run() 方法运行完毕
- stop() 方法被调用
- 在运行过程中出现未捕获的异常
4.线程调度
- 多个线程处于可运行状态，需要排队等待 CPU 资源，每个线程会自动获得一个线程的优先级
- 优先级的高低反映线程的重要或紧急程度
- 可运行状态的线程按优先级排队，线程调度依据建立在优先级基础上的“先到先服务”原则
- 线程调度管理器负责线程排队和在线程之间分配 CPU
- 按线程调度算法进行调度
- 当线程调度管理器选中某个线程时，该线程获得 CPU 资源进入运行状态
- 线程调度是抢占式调度
- 在当前线程执行过程中若有一个更高优先级的线程进入可运行状态，则立即被调度执行
（1）线程优先级
- 线程的优先级用 1~10 表示，10表示优先级最高
- 默认值为5
- 每个优先级对应一个 Thread 类的公用静态常量
- 每个线程的优先级都介于 Thread.MIN_PRIORITY 和 Thread.MAX_PRIORITY之间
- 可以通过 setPriority(int grade) 方法更嗨
- 参数表示要设置的优先级，必须是 1~10 的整数
（2）实现线程调度的方法
- join() 方法
- 使当前线程暂停执行，等调用该方法的线程结束后再继续执行本线程
- 3种重载形式
- public final void join()
- public final void join(long millis)
- public final void join(long millis,int nanos)
public class BhhThread extends Thread {
public BhhThread(String name){
super(name);
}
public void run(){
for(int i=0;i<5;i++){
//输出当前线程的名称
System.out.println(Thread.currentThread().getName()+" "+i);
}
}
}
public class ThreadTest{
public static void main(String[] args){
for(int i=0;i<10;i++){
if(i==5){
BhhThread bt=new BhhThread("BhhThread");
try{
bt.start();
bt.join();
//把该线程通过 join() 方法插入到主线程之前
//阻塞主线程直到该线程完成后再继续执行
}catch (InterruptedException ie){
ie.getStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+" "+i);
}
}
//使用 join() 方法实现两个线程之间的数据传递
public class BhhThread extends Thread {
public String value1;
public String value2;
public void run(){
value1="value1 已赋值";
value2="value2 已赋值";
}
}
public class ThreadTest{
public static void main(String[] args)throws InterruptedException{
BhhThread bt=new BhhThread();
bt.start();
bt.join();
System.out.println("value1:"+bt.value1);
System.out.println("value2:"+bt.value2);
}
}
- sleep() 方法
- 会让当前线程睡眠（停止执行）millis 毫秒
- 线程由运行中的状态进入不可运行状态
- 睡眠时间过后线程会再次进入可运行状态
public class Wait {
public static void bySec(long s){
for(int i=0;i<s;i++){
System.out.println((i+1)+"秒");
try{
Thread.sleep(1000);
}catch (InterruptedException ie){
ie.getStackTrace();
}
}
}
}
public class Test {
public static void main(String[] args){
System.out.println("wait");
Wait.bySec(5);
System.out.println("start");
}
}
- yield() 方法
- 可让当前线程暂停执行，允许其他线程执行
- 但该线程仍处于可运行状态，并不变为阻塞状态
- 系统选择其他相同或更高优先级线程执行
- 若无其他相同或更高优先级线程，则该线程继续执行
public class FirstThread extends Thread{
public void run(){
for(int i=0;i<5;i++){
System.out.println("第一个线程执行第"+(i+1)+"次……");
Thread.yield();//暂停该线程
}
}
}
public class SecondThread extends Thread{
public void run(){
for(int i=0;i<5;i++){
System.out.println("第二个线程执行第"+(i+1)+"次……");
Thread.yield();//暂停该线程
}
}
}
public class Test {
public static void main(String[] args){
FirstThread ft=new FirstThread();
SecondThread st=new SecondThread();
ft.start();
st.start();
}
}
- sleep() 方法和 yield() 方法之间的区别
| sleep() 方法 | yield() 方法 |
|---|---|
| 使当前线程进入被阻塞的状态 | 将当前线程转入暂停执行的状态 |
| 即使没有其他等待运行的线程，当前线程也会等待指定的时间 | 如果没有其他等待执行的线程，当前线程会马上恢复执行 |
| 其他等待执行的线程的机会是均等的 | 会运行优先级相同或更高的线程 |
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
