线程是比进程还要小的运行单位，一个进程包含多个线程。
什么是多线程
线程的创建
两种方式：
- 创建一个Thread类，或者一个Thread子类的对象
- 创建一个实现Runnable接口的类的对象
Thread类：
Runnable接口
- 只有一个方法run()
- Runnable是java中用以实现线程的接口
- 任何实现线程功能的类都必须实现该接口
继承Thread类的方式创建线程类，重写run方法：
package com.imooc.thread;
class MyThread extends Thread{
public void run(){
System.out.println(getName()+"该线程正在执行!");
}
}
public class ThreadTest{
public static void main(String[] args){
System.out.println("主线程1");
MyThread mt = new MyThread();
mt.start();
System.out.println("主线程2");
}
}
Runnable创建线程：
为什么要实现Runnable接口？
因为：
- Java不支持多继承
- 当你不打算重写Thread类的其他方法
package com.imooc.thread;
class PrintRunnable implements Runnable{
@Override
public void run() {
int i = 1;
while (i<=5){
System.out.println(Thread.currentThread().getName()+"正在运行");
i++;
}
}
}
public class ThreadTest{
public static void main(String[] args){
PrintRunnable pr = new PrintRunnable();
Thread t1 = new Thread(pr);
t1.start();
Thread t2 = new Thread(pr);
t2.start();
}
}
线程的状态和生命周期
线程的状态
线程的生命周期
sleep方法：在指定的毫秒数内，让线程休眠。（暂停执行）
public static void sleep(long millis)
参数单位：毫秒
示例：
class MyThread implements Runnable{
@Override
public void run() {
for(int i = 0; i<10;i++){
System.out.println(Thread.currentThread().getName()+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class Test {
public static void main(String[] args){
MyThread m = new MyThread();
Thread t = new Thread(m);
t.start();
}
}
调用sleep时需要捕获异常。
join()方法：优先执行线程。（抢占资源）
public final void join()
join方法的参数为毫秒，代表：超过此时间交出资源使用权。
示例：
class MyThread implements Runnable{
@Override
public void run() {
for(int i = 0; i<10;i++){
System.out.println(Thread.currentThread().getName()+i);
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class Test {
public static void main(String[] args){
MyThread m = new MyThread();
Thread t = new Thread(m);
t.start();
try {
t.join(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
for(int j = 0; j<10;j++){
System.out.println("主线程");
}
}
}
线程的调度
线程优先级
- Java为线程类提供了10个优先级
- 优先级可以用整数1-10表示，超出范围会抛出异常
- 主线程默认优先级为5
- 优先级常量
- MAX_PRIORITY : 最高优先级（10）
- MIN_PRIORITY : 最低优先级（1）
- NORM_PRIORITY ：默认优先级（5）
测试代码：
class MyThread implements Runnable{
private String name;
public MyThread(String name){
this.name = name;
}
@Override
public void run() {
for(int i = 0; i<10;i++){
System.out.println(Thread.currentThread().getName()+i+name);
}
}
}
public class Test {
public static void main(String[] args){
int i = Thread.currentThread().getPriority();
MyThread m = new MyThread("Allen");
Thread t = new Thread(m);
MyThread m1 = new MyThread("ming");
Thread t1 = new Thread(m1);
t.setPriority(Thread.MAX_PRIORITY);
t1.setPriority(Thread.MIN_PRIORITY);
int y = t.getPriority();
int y1 = t1.getPriority();
System.out.println("Allen线程优先级"+y);
System.out.println("ming线程优先级"+y1);
t.start();
t1.start();
}
}
线程同步
多线程运行时的问题：
- 各个线程是通过竞争CPU时间而获得运行机会的
- 各个线程什么时候得到CPU时间、占用多久，是不可预测的
- 一个正在运行着的线程在什么地方被暂停是不确定的
使用synchronized关键字加锁。同一时刻只能单个操作。
synchronized关键字可以用在：成员方法、静态方法、语句块
public synchronized void F(){}
public static synchronized void F(){}
synchronized (){}
线程间通信
Java中的线程通信和Python中的差不多，通过中间队列类存储，由消费者和生产者负责放入和取出。
wait方法：中断方法的执行，使线程等待
notify方法：唤醒处于等待的某一个线程
notifyAll方法：唤醒处于等待的全部线程
小结
创建线程的两种方式：
- 继承Thread类创建线程
new Thread().start()
- 实现Runnable接口创建线程
new Thread(new MyRunable()).start()
线程的5种状态：
- 新建
- 可运行
- 运行
- 阻塞
- 终止
sleep、join、wait、notify、notifyAll方法：
线程优先级：
- 最高、最低。
- 获取优先级、设置优先级。
- 先启动的线程尽管优先级低，也会可能先执行。
线程同步：
synchronized关键字，可以用在：成员方法、静态方法、语句块。
上述文章如有帮助记得点赞呦，关注后第一时间获得最新笔记，持续更新~
