第八章，多线程

高级编程

文章目录

• 高级编程
• • • • 第八章，多线程
      • • 一，多线程
        • 二，主线程
        • 三，线程的创建和启动
        • 四，线程的状态
        • 五，同步方法
        • 六，线程安全的类型
        • 七，常见类型对比

第八章，多线程

一，多线程

• 什么是多线程

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

• 多线程的好处

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

二，主线程

• 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类
    • 定义MyThread类继承Thread类
    • 重写run()方法，编写线程执行体
    • 创建线程对象，调用start()方法启动线程
    • 多个线程交替执行，不是真正的“并行”
    • 线程每次执行时长由分配的CPU时间片长度决定

  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(); //启动线程
  }
  

注意：启动线程是否可以直接调用run()方法？

• 实现java.lang.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类
    • 编写简单，可直接操作线程
    • 适用于单继承
  • 实现Runnable接口
    • 避免单继承局限性
    • 便于共享资源

四，线程的状态

• 线程的所有状态

  • NEW:安排了工作,还未开始行动

  • RUNNABLE:可工作的.又可以分成正在工作中和即将开始工作.

  • BLOCKED:这几个都表示排队等着其他事情

  • WAITING:这几个都表示排队等着其他事情

  • TIMED_WAITING:这几个都表示排队等着其他事情

  • TERMINATED:工作完成了

    

• 线程调度

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

    

• 线程优先级

  • 线程优先级由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);
           //省略代码……
    	}}
    
    

    

• 线程休眠

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

• 线程的强制运行

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

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

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

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

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

    public static void 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）同步代码

六，线程安全的类型

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

  public boolean add(E e) {
         ensureCapacityInternal(size + 1); 
        elementData[size++] = e;
          return true;
  }
  

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

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

  注意：ArrayList为非线程安全的类型

  

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

七，常见类型对比

• Hashtable && HashMap

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

• StringBuffer && StringBuilder

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