Java高级特性：多线程

柔情只为你懂 2024-04-08 09:23 75阅读 0赞

**目录**

多线程

主线程

线程的创建和启动

1、继承Thread类创建线程

2、实现Runnable接口创建线程

线程状态

1、线程优先级

2、线程休眠

3、线程的强制运行

4、线程的礼让

多线程共享数据引发的问题

Hashtable 与 HashMap的区别

--------------------

### 多线程 ###

什么是多线程：如果在一个进程中同时运行了多个线程，用来完成不同的工作，则称之为“多线程”多个线程交替占用CPU资源，而非真正的并行执行

**多线程好处：**1、充分利用CPU的资源，2、简化编程模型，3、带来良好的用户体验

Thread类：Java提供了java.lang.Thread类支持多线程编程

#### **主线程** ####

main()方法即为主线程入口

产生其他子线程的线程

必须最后完成执行，因为它执行各种关闭动作

public static void main(String args[]) {
    		Thread t= Thread.currentThread(); 
    		System.out.println("当前线程是: "+t.getName()); 
    		t.setName("MyJavaThread"); 
    		System.out.println("当前线程名是: "+t.getName()); 
    }

#### 线程的创建和启动 ####

在Java中创建线程的两种方式

继承java.lang.Thread类

实现java.lang.Runnable接口

**使用线程的步骤:**1、定义线程2、创建线程对象3、启动线程4、终止线程

#### **1、继承Thread类创建线程** ####

定义MyThread类继承Thread类

重写run()方法，编写线程执行体

创建线程对象，调用start()方法启动线程

**实例：**

public class MyThread extends Thread{
 //重写run()方法
 	public void run(){
 		for(int i=1;i<100;i++){			System.out.println(
 Thread.currentThread().getName()+":"+i);
 }
 }
 }

public static void main(String[] args) {
    		MyThread thread = new MyThread();
    		thread.start(); //启动线程
    }

多个线程交替执行，不是真正的“并行” 线程每次执行时长由分配的CPU时间片长度决定

MyThread t1 = new MyThread();
    MyThread t2 = new MyThread();
    t1.start();
    t2.start();

启动线程不可以直接调用run()方法，要使用start()方法

#### 2、实现Runnable接口创建线程 ####

定义MyRunnable类实现Runnable接口

实现run()方法，编写线程执行体

创建线程对象，调用start()方法启动线程

public class MyRunnable implements Runnable{
 	public void run(){
 		for(int i=1;i<100;i++){			System.out.println(
 Thread.currentThread().getName()+":"+i);
 }
 }
 }

public static void main(String[] args) {
    		MyRunnable myRunnable = new MyRunnable();
    		Thread myThread = new Thread(myRunnable);	
    		thread.start(); //启动线程
    }

**继承Thread类：** 1、编写简单，可直接操作线程；2、适用于单继承

**实现Runnable接口：1、**避免单继承局限性；2、便于共享资源

### 线程状态 ###

1、创建状态；2、就绪状态；3、运行状态；4、阻塞状态；5、死亡状态

![936e704563ec4f9186b0501fb9e89ed4.png][]

**线程调度：线程调度指按照特定机制为多个线程分配CPU的使用权**

<table style="width:500px;"> 
 <tbody> 
 <tr> 
 <td>方法</td> 
 <td>说明</td> 
 </tr> 
 <tr> 
 <td> void setPriority(int &nbsp;newPriority) </td> 
 <td> 更改线程的优先级 </td> 
 </tr> 
 <tr> 
 <td> static void sleep(long millis) </td> 
 <td> 在指定的毫秒数内让当前正在执行的线程休眠 </td> 
 </tr> 
 <tr> 
 <td> void join() </td> 
 <td> 等待该线程终止 </td> 
 </tr> 
 <tr> 
 <td> static void yield() </td> 
 <td> 暂停当前正在执行的线程对象，并执行其他线程 </td> 
 </tr> 
 <tr> 
 <td> void interrupt() </td> 
 <td> 中断线程 </td> 
 </tr> 
 <tr> 
 <td> boolean isAlive() </td> 
 <td> 测试线程是否处于活动状态 </td> 
 </tr> 
 </tbody> 
</table>

#### 1、**线程优先级** ####

线程优先级由1~10表示，1最低，默认优先级为5

优先级高的线程获得CPU资源的概率较大

**实例：**

public class Runable implements Runnable{
 //重写run方法
 @Override
 public void run() {
 for (int i = 1; i < 10; i++) {
 Thread thread = Thread.currentThread();
 System.out.println("你好：来自线程：" + thread.getName());
 }
 }
 public static void main(String[] args) {
 Runable runable = new Runable();
 Thread thread1 = new Thread(runable);
 Thread thread2 = new Thread(runable);
 //修改线程名字
 thread1.setName("A");
 thread2.setName("B");
 //设置线程优先级
 thread1.setPriority(8);
 thread2.setPriority(4);
 //启动线程
 thread1.start();
 thread2.start();
 }
 }

#### 2、线程休眠 ####

让线程暂时睡眠指定时长，线程进入阻塞状态，睡眠时间过后线程会再进入可运行状态

实例：

public class Runable implements Runnable{
 //重写run方法
 @Override
 public void run() {
 for (int i = 1; i < 10; i++) {
 try {
 //线程休眠，并处理异常
 Thread.sleep(1000);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 Thread thread = Thread.currentThread();
 System.out.println("你好：来自线程：" + thread.getName());
 }
 }
 public static void main(String[] args) {
 Runable runable = new Runable();
 Thread thread1 = new Thread(runable);
 Thread thread2 = new Thread(runable);
 //修改线程名字
 thread1.setName("A");
 thread2.setName("B");
 //设置线程优先级
 thread1.setPriority(8);
 thread2.setPriority(4);
 //启动线程
 thread1.start();
 thread2.start();
 }
 }

#### 3、线程的强制运行 ####

使当前线程暂停执行，等待其他线程结束后再继续执行本线程

方法：

1、**public final void join()**

**2、****public final void join(long mills)**

**3、****public final void join(long** **mills,int** **nanos****)**

millis：以毫秒为单位的等待时长，nanos：要等待的附加纳秒时长，需处理InterruptedException异常

实例：

重写run方法

public class MyRunnable implements Runnable{
 private String name;
 
 private String gender;
 
 public MyRunnable(String name, String gender) {
 this.name = name;
 this.gender = gender;
 }
 
 public MyRunnable() {
 }
 
 public String getName() {
 return name;
 }
 
 public void setName(String name) {
 this.name = name;
 }
 
 public String getGender() {
 return gender;
 }
 
 public void setGender(String gender) {
 this.gender = gender;
 }
 
 @Override
 public void run() {
 for(int i = 0; i < 5; i++){
 try {
 Thread.sleep(2000);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 System.out.println(Thread.currentThread().getName() + "\t" + i);
 }
 }
 }

实现线程阻塞：

public class JoinThreadTest {
 public static void main(String[] args) {
 MyRunnable myRunnable = new MyRunnable("张三","男");
 Thread myThread = new Thread(myRunnable);
 
 myThread.start();
 
 for (int i=0;i<20;i++){
 if(i==5){
 try {
 //线程阻塞
 myThread.join();
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 System.out.println(Thread.currentThread().getName()+"运行："+i);
 }
 }
 }

#### **4、线程的礼让** ####

暂停当前线程，允许其他具有相同优先级的线程获得运行机会

该线程处于就绪状态，不转为阻塞状态

方法：

public static void yield()

**只是提供一种可能，但是不能保证一定会实现礼让**

实例：

重写run方法

public class YieldRunnable implements Runnable{
 @Override
 public void run() {
 for(int i=0;i<15;i++){
 String name = Thread.currentThread().getName();
 System.out.println(name+"正在运行："+i);
 /*if(i==3){
 System.out.print(name + "线程礼让：");
 Thread.yield();
 }*/
 System.out.print(name + "线程礼让：");
 Thread.yield();
 }
 }
 }

实现线程礼让：

public class YieldThreadTest {
        public static void main(String[] args) {
            YieldRunnable runnable = new YieldRunnable();
    
            Thread t1 = new Thread(runnable);
            t1.setName("线程A");
            Thread t2 = new Thread(runnable);
            t2.setName("线程B");
    
            t1.start();
            t2.start();
        }
    
    }

#### 多线程共享数据引发的问题 ####

多个线程操作同一共享资源时，将引发数据不安全问题

使用同步方法和同步代码块可以解决这些问题

使用synchronized修饰的方法控制对类成员变量的访问

**同步方法语法:**

访问修饰符 synchronized 返回类型 方法名（参数列表）{……}
    或者
    synchronized 访问修饰符 返回类型 方法名（参数列表）{……}

同步方法实例：

同步方法多个线程抢火车票

public class TrainRunnable implements Runnable{
 private int num;
 
 private int count = 10;
 
 private boolean flag = false;
 
 @Override
 public void run() {
 while (!flag) {
 //省略代码：判断是否余票
 sale();
 }
 System.out.println("票已抢完!");
 }
 
 private synchronized void sale(){
 if (count <= 0) {
 flag = true;
 return;
 }
 
 try {
 Thread.sleep(500); //模拟网络延时
 } catch (InterruptedException e) {//…}
 e.printStackTrace();
 }
 count--;
 num++;
 System.out.println(Thread.currentThread().getName()+"抢到第"+num+"张票，剩余"+count+"张票！");
 }
 
 public static void main(String[] args) {
 TrainRunnable trainTest1 = new TrainRunnable();
 Thread a = new Thread(trainTest1);
 Thread b = new Thread(trainTest1);
 Thread c = new Thread(trainTest1);
 a.setName("客户：A");
 b.setName("客户：B");
 c.setName("客户：C");
 
 
 a.start();
 b.start();
 c.start();
 }
 }

**同步代码块**

使用synchronized关键字修饰的代码块

同步代码块语法：

synchronized(syncObject){
        //需要同步的代码
    }

syncObject为需同步的对象，通常为this，效果与同步方法相同

同步代码块多个线程抢火车票：

public class TrainThread implements Runnable{
 private int num;
 
 private int count = 10;
 
 @Override
 public void run() {
 while (true) {
 //省略代码：判断是否余票
 synchronized (this){
 if (count <= 0) {
 System.out.println("票已抢完!");
 break;
 }
 
 try {
 Thread.sleep(500); //模拟网络延时
 } catch (InterruptedException e) {//…}
 e.printStackTrace();
 }
 count--;
 num++;
 System.out.println(Thread.currentThread().getName()+"抢到第"+num+"张票，剩余"+count+"张票！");
 }
 
 }
 }
 
 public static void main(String[] args) {
 TrainThread trainTest1 = new TrainThread();
 Thread a = new Thread(trainTest1);
 Thread b = new Thread(trainTest1);
 Thread c = new Thread(trainTest1);
 a.setPriority(Thread.MAX_PRIORITY);
 a.setName("客户：A");
 b.setName("客户：B");
 c.setName("客户：C");
 
 a.start();
 b.start();
 c.start();
 }
 }

**多个并发线程访问同一资源的同步代码块时**

同一时刻只能有一个线程进入synchronized（this）同步代码块

当一个线程访问一个synchronized（this）同步代码块时，其他synchronized（this）同步代码块同样被锁定

当一个线程访问一个synchronized（this）同步代码块时，其他线程可以访问该资源的非synchronized（this）同步代码

**线程安全的类型**

<table style="width:500px;"> 
 <tbody> 
 <tr> 
 <td></td> 
 <td>方法是否同步</td> 
 <td>效率</td> 
 <td>适合场景</td> 
 </tr> 
 <tr> 
 <td>线程安全</td> 
 <td>是</td> 
 <td>低</td> 
 <td>多线程并发共享资源</td> 
 </tr> 
 <tr> 
 <td>非线程安全</td> 
 <td>否</td> 
 <td>高</td> 
 <td>单线程</td> 
 </tr> 
 </tbody> 
</table>

**为达到安全性和效率的平衡，可以根据实际场景来选择合适的类型**

#### **Hashtable 与 HashMap的区别** ####

Hashtable：继承关系

1、实现了Map接口，Hashtable继承Dictionary类

2、线程安全，效率较低

3、键和值都不允许为null

HashMap：继承关系

1、实现了Map接口，继承AbstractMap类

2、非线程安全，效率较高

3、键和值都允许为null

[936e704563ec4f9186b0501fb9e89ed4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/03eba21819704fdfaf8ce5d0a6b7cd4f.png