第八章 多线程

第八章 多线程

进程：应用程序的执行实例，有独立的内存空间和系统资源

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

什么是多线程

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

多线程好处

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

主线程

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

继承Thread类创建线程

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

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()方法？

实现Runnable接口创建线程

//定义MyRunnable类实现Runnable接口
public class MyRunnable implements Runnable{
    //实现run()方法，编写线程执行体
	public void run(){
		for(int i=1;i<100;i++){			    
		    System.out.println(Thread.currentThread().getName()+":"+i);
}}}
//创建线程对象，调用start()方法启动线程
public static void main(String[] args) {
		MyRunnable myRunnable = new MyRunnable();
		Thread myThread = new Thread(myRunnable);	
		thread.start(); //启动线程}

实现Callable<>接口创建线程

import java.util.concurrent.Callable;
	//实现Callable<数据类型>接口
public class MyCallable implements Callable<String> {
	//重写call方法，注意call方法有返回值默认返回值类型为Object
    @Override
    public String call() throws Exception {
        for (int i = 1; i <=10 ; i++) {
            System.out.println(Thread.currentThread().getName()+"=="+i);
        }

        return "这是通过实现Callable创建的线程！";
    }
}

//测试
public class test03 {
    public static void main(String[] args) {
        MyCallable myCallable=new MyCallable();
        
        FutureTask<String> futureTask1=new FutureTask<>(myCallable);
        FutureTask<String> futureTask2=new FutureTask<>(myCallable);
        
        Thread thread1=new Thread(futureTask1,"线程1");
        Thread thread2=new Thread(futureTask2,"线程2");
        
        thread1.start();
        thread2.start();
        
        //接收返回值
           try {
            System.out.println(futureTask1.get());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

比较两种创建线程的方式

• 继承Thread类

  • 编写简单，可直接操作线程

  • 适用于单继承

• 实现Runnable接口

  • 避免单继承局限性

  • 便于共享资源

线程的状态

线程调度

• 线程调度指按照特定机制为多个线程分配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);
         //省略代码……
  	}}
  

线程休眠

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

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

线程的强制运行

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

public final void join()
public final void join(long mills)// millis：以毫秒为单位的等待时长
public final void join(long mills,int nanos)//nanos：要等待的附加纳秒时长
//需处理InterruptedException异常

线程的礼让

• 暂停当前线程，允许其他具有相同优先级的线程获得运行机会
• 该线程处于就绪状态，不转为阻塞状态

public static void yield()

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

同步方法与同步代码块

• 使用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()方法定义

  ArrayList为非线程安全的类型

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

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

StringBuffer && StringBuilder

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