08多线程

多线程

进程线程：

**进程：**正在运行的程序

是系统进行资源分配和调用的独立单位

每一个进程都有它自己的内存空间和系统资源

线程：

CPU调度和分派的基本单位；进程中执行运算的最小单位，可完成一个独立的顺序控制流程

**单线程：**一个进程如果只有一条执行路径，则称为单线程

多线程：

概念：

如果一个进程中同时运行了多个线程，用来完成不同的工作，则称之为“多线程”

多个线程交替占用CPU资源，而非真正的并行执行

好处：

1. 充分利用CPU资源
2. 简化编程模型
3. 带来良好的用户体验

主线程：

Thread类

• java提供 java.lang.Thread 类支持多线程编程

• 主线程：

  • main()方法即为主线程入口
  • 产生其他子线程的线程
  • 必须最后完成执行，因为它执行各种关闭动作

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

线程的创建和启动：

创建的两种方式：

• 继承java.lang.Thread类
• 实现java.lang.Runnable接口

步骤：定义线程----->创建线程对象----->启动线程----->终止线程

​

▶继承Thread类创建线程

1. 定义MyThread类继承Thread类
2. 在MyThread类中重写run()方法，编写线程执行体
3. 创建线程对象
4. 调用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(); //启动线程(就绪状态)
    
    //static Thread currentThread():返回当前正在执行的线程对象的引用
		//可以知道当前线程:
		System.out.println(Thread.currentThread().getName());   //main
}

• run()方法是用来封装被线程执行的代码

• 多个线程交替执行，并不是真正的“并行”

• 线程每次执行时长由分配的CPU时间长度决定

run()和start()的区别：

​ run()：封装线程执行的代码，直接调用，相当于普通方法的调用

​ start()：启动线程，然后由JVM调用此线程的run()方法

设置和获取线程名称：

Thread类中设置和获取线程名称方法：

//void setName(String name):将线程的名称更改为等于参数name.要在MyThread类中创建有无参构造方法
//无参构造方法
MyThread my1 =new MyThread();		
MyThread my2 =new MyThread();
		
my1.setName("哇哈哈");
my2.setName("笑嘻嘻");

//有参构造方法 【super继承父类的name方法】
MyThread my1 =new MyThread("哇哈哈");		
MyThread my2 =new MyThread("笑嘻嘻");	

//String getName():返回此线程的名称

▶实现Runnable接口创建线程

1. 定义MyRunnable类实现Runnable接口
2. 在MyRunnable类中实现run()方法，编写线程执行体
3. 创建线程对象，把MyRunnable对象作为构造方法的参数。
4. 调用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 myThread1 = new Thread(myRunnable);	
    Thread myThread2 = new Thread(myRunnable);
     //启动线程
    thread1.start();
    thread2.start();
}

▶实现Callable接口创建线程

首先new 一个我的类实现实例化，然后将我生成的实例对象注册进入到FutureTask类中，然后将FutureTask类的实例注册进入Thread中运行。

最后可以采用FutureTask中的get() 方法获取自定义线程的返回值。

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {  //可以用泛型Callable<V>

	@Override
	public String call() throws Exception {
		for(int i = 0; i<10; i++){
			System.out.println(Thread.currentThread().getName()+":"+i);	
		}		
		return "这是我的返回值";
	}
}

public static void main(String[] args) throws Exception {
		
		MyCallable mc = new MyCallable();
		//线程1
		FutureTask ft1 = new FutureTask(mc);
		Thread thread1 = new Thread(ft1);
		thread1.start();
		//线程2
		FutureTask ft2 = new FutureTask(mc);
		Thread thread2 = new Thread(ft2);
		thread2.start();
    
		Object s = ft2.get();  
		System.out.println(s);
	}

三种方式的比较：

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

实现Runnable接口：避免单继承局限性；便于共享资源 :把线程和程序的代码、数据有效分离，体现面向对象的设计思想（推荐使用）

实现Callable接口： FutureTask实现了Runnable接口和Future接口 ；call方法可以抛出异常；FutureTask中的get()方法获取自定义线程的返回值.

---

线程的状态：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UjxZjpu0-1660047360051)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\1659491008324.png)]

新建 就绪 sleep阻塞 运行 死亡

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C2Wo7XP4-1660047360053)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\1660015473572.png)]

线程的调度：

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

• 分时调度模型：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片
• java使用 抢占式调度模型：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么随机选一个。优先级高的获取的CPU时间相对多些

方 法	说 明
void setPriority(int newPriority)	更改线程的优先级
static void sleep(long millis)	在指定的毫秒数内让当前正在执行的线程休眠
void join()	等待该线程终止
static void yield()	暂停当前正在执行的线程对象，并执行其他线程
void interrupt()	中断线程
boolean isAlive()	测试线程是否处于活动状态

线程优先级：

• 线程优先级由1~10表示，1最低，默认优先级为5
• 优先级高的线程获得CPU资源的概率较大

public static void main(String[] args) {
    //创建线程对象并指定线程名
    Thread t1 = new Thread(new MyThread(),"线程A");  
    Thread t2 = new Thread(new MyThread(),"线程B");
    t1.setPriority(Thread.MAX_PRIORITY);  //最高级优先级：10
    t2.setPriority(Thread.MIN_PRIORITY);  //最低优先级：1
    									  //默认是5
    //省略代码……	
}

设置和获取优先级的方法：

1. public final int getPriority()：返回此线程的优先级
2. public final void setPriority(int newPriority)：更改此线程的优先级

线程控制----

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XuCOJE32-1660047360054)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\1660014030697.png)]

线程休眠sleep：

• 让线程暂时睡眠指定时长，线程进入阻塞状态

• 睡眠时间过后线程会再进入可运行状态

  public static void sleep(long millis);
  

  • millis为休眠时长，以毫秒为单位
  • 调用sleep()方法需处理InterruptedException异常

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 e) {
				e.printStackTrace();
             }
         }
    }
}

线程的强制运行join：

强制执行当前线程，join写在哪个线程，就阻塞谁

public final void join()
public final void join(long mills)
public final void join(long mills,int nanos)

示例：

public static void main(String[] args) {
      Thread temp = new Thread(new MyThread());
      temp.start();
    
      for(int i=0;i<20;i++){
          if(i==5){				
              try {
                  temp.join();   //阻塞主线程，子线程强制执行
              } catch (InterruptedException e) {
                  e.printStackTrace(); 
              }
          }			
     System.out.println(Thread.currentThread().getName()+"运行："+i);
     } 
      //省略代码…
}

线程的礼让yield：

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

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

  public static void yield()
  

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

public class MyThread implements Runnable{
     public void run(){
         for(int i=0;i<5;i++){
             System.out.println(Thread.currentThread().getName()+"正在运行："+i);
             if(i==3){
                 System.out.print("线程礼让：");
                 Thread.yield();	 
             } 
         } 
     }
}

join()方法和yield()方法的区别是:

同步方法：

• 使用synchronized修饰的方法控制对类成员变量的访问
• synchronized就是为当前的线程声明一把锁

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

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

同步代码块：

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

  synchronized(syncObject任意对象就是一把锁){
      //需要同步的代码
  }
  

  • syncObject为需同步的对象，通常用this

  • 效果与同步方法相同

    public void run() {
        while (true) {
            synchronized (this) {   //同步代码块
            // 省略修改数据的代码......
           	// 省略显示信息的代码......
    		}
        }
    }
    

代码解析：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZBN9yMJ4-1660047360055)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\1660022546695.png)]

• 好处：解决了多线程的数据安全
• 弊端：当线程很多时：因为每个线程会去判断同步上的锁，耗费资源，降低了程序的运行效率

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

• 同一时刻只能有一个线程进入synchronized（this）同步代码块
• 当一个线程访问一个synchronized（this）同步代码块时，其他synchronized（this）同步代码块同样被锁定
• 当一个线程访问一个synchronized（this）同步代码块时，其他线程可以访问该资源的非synchronized（this）同步代码

线程安全的类型：

one:

​ ArrayList为非线程安全的类型

• 查看ArrayList类的add()方法定义

  public boolean add(E e) {
        ensureCapacityInternal(size + 1);  //集合扩容 ，确保能新增数据
        elementData[size++] = e; //在新增位置存放数据
        return true;
  }
  

• ArrayList类的add()方法为非同步方法

• 当多个线程向同一个ArrayList对象添加数据时，可能出现数据不一致问题

	方法是否同步	效率比较	适合场景
线程安全	是	低	多线程并发共享资源
非线程安全	否	高	单线程

常见类型对比：

Hashtable && HashMap

• Hashtable

  • 继承关系
    • 实现了Map接口，Hashtable继承Dictionary类
  • 线程安全，效率较低
  • 键和值都不允许为null

• HashMap

  • 继承关系
    • 实现了Map接口，继承AbstractMap类
  • 非线程安全，效率较高
  • 键和值都允许为null

StringBuffer&& StringBuilder

• 前者线程安全，后者非线程安全

------------- | ------------ | ---------------------- |
| 线程安全 | 是 | 低 | 多线程并发共享资源 |
| 非线程安全 | 否 | 高 | 单线程 |

常见类型对比：

Hashtable && HashMap

• Hashtable

  • 继承关系
    • 实现了Map接口，Hashtable继承Dictionary类
  • 线程安全，效率较低
  • 键和值都不允许为null

• HashMap

  • 继承关系
    • 实现了Map接口，继承AbstractMap类
  • 非线程安全，效率较高
  • 键和值都允许为null

StringBuffer&& StringBuilder

• 前者线程安全，后者非线程安全