Java入门—多线程

线程是比进程还要小的运行单位，一个进程包含多个线程。

什么是多线程

线程的创建

两种方式：

1. 创建一个Thread类，或者一个Thread子类的对象
2. 创建一个实现Runnable接口的类的对象

Thread类：

• Thread是一个线程类，位于java.lang包下

  
  
  image.png

• Thread类的常用方法

  
  
  image.png

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接口？

因为：

1. Java不支持多继承
2. 当你不打算重写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(); } } 

线程同步

多线程运行时的问题：

1. 各个线程是通过竞争CPU时间而获得运行机会的
2. 各个线程什么时候得到CPU时间、占用多久，是不可预测的
3. 一个正在运行着的线程在什么地方被暂停是不确定的

使用synchronized关键字加锁。同一时刻只能单个操作。

synchronized关键字可以用在：成员方法、静态方法、语句块

public synchronized void F(){} public static synchronized void F(){} synchronized (){} 

线程间通信

Java中的线程通信和Python中的差不多，通过中间队列类存储，由消费者和生产者负责放入和取出。

wait方法：中断方法的执行，使线程等待
notify方法：唤醒处于等待的某一个线程
notifyAll方法：唤醒处于等待的全部线程

小结

创建线程的两种方式：

1. 继承Thread类创建线程 new Thread().start()
2. 实现Runnable接口创建线程 new Thread(new MyRunable()).start()

线程的5种状态：

1. 新建
2. 可运行
3. 运行
4. 阻塞
5. 终止

sleep、join、wait、notify、notifyAll方法：

线程优先级：

• 最高、最低。
• 获取优先级、设置优先级。
• 先启动的线程尽管优先级低，也会可能先执行。

线程同步：
synchronized关键字，可以用在：成员方法、静态方法、语句块。

上述文章如有帮助记得点赞呦，关注后第一时间获得最新笔记，持续更新~