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. 重写run()方法，编写线程执行体

3. 创建线程对象，调用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时间长度决定

run()和start()的区别：

▶实现Runnable接口创建线程

1. 定义MyRunnable类实现Runnable接口
2. 实现run()方法，编写线程执行体
3. 创建线程对象，调用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类：编写简单，可直接操作线程；适用于单继承

实现Runnable接口：避免单继承局限性；便于共享资源 （推荐使用）

线程的状态：

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

线程的调度：

线程调度指按照特定机制为多个线程分配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);  //最高级优先级
    t2.setPriority(Thread.MIN_PRIORITY);  //最低优先级
    //省略代码……	
}

线程休眠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) {   //同步代码块
            // 省略修改数据的代码......
           	// 省略显示信息的代码......
    		}
        }
    }
    

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

• 同一时刻只能有一个线程进入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

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