6. 多线程基础-阿里云开发者社区

6.多线程

6.1 多线程概念

进程是什么(process)

对一个程序的运行状态, 以及在运行中所占用的资源(内存, CPU)的描述;

一个进程可以理解为一个程序; 但是反之, 一个程序就是一个进程, 这句话是错的。

进程的特点:

独立性: 不同的进程之间是相互独立的, 相互之间资源不共享；
动态性: 进程在程序中不是静止不动的, 而是一直是活动状态；
并发性: 多个进程可以在一个处理器上同时运行, 互不影响；

线程是什么(thread)

是进程的一个组成部分, 一个进程中可以包含多个线程, 每一个线程都可以去处理一项任务；

进程在开辟的时候, 会自动的创建一个线程, 这个线程叫做主线程；

一个进程包含多个线程, 且至少是一个, 如果一个进程中没有线程了, 这个进程会被终止；

多线程的执行是抢占式的, 多个线程在同一个进程中并发执行任务, 其实就是CPU快速的在不同的线程之间进行切换,

进程与线程的关系和区别

一个程序运行后, 至少有一个进程
一个进程包含多个线程, 至少一个线程
进程之间是资源不共享的, 但是线程之间是资源共享的
系统创建进程的时候, 需要为进程重新分配系统资源, 而创建线程则容易很多, 因此使用多线程在进行并发任务的时候, 效率比多进程高

区别并行和并发

并行：指在同一时刻，有多条指令在多个处理器上同时执行；

并发：指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行；

6.2 创建线程的方式

继承Thread类

Thread是所有线程类的父类, 实现了对线程的抽取和封装；

使用继承Thread类实现多线程的步骤:

继承Thread类, 写一个Thread的子类
在子类中, 重写父类中的run方法, run方法就代表了这个线程需要处理的任务(希望这个线程处理什么任务, 就把这个任务写到run方法中), 因此, run方法也被称为线程执行体
实例化这个子类对象, 即是开辟了一个线程
调用start方法, 来执行这个线程需要处理的任务(启动线程)

public class Demo01 {
public static void main(String[] args) {
//创建自定义线程对象
MyThread mt = new MyThread("新的线程！");
//开启新线程
mt.start();
//在主方法中执行for循环
for (int i = 0; i < 10; i++) {
  System.out.println("main线程！"+i);
}
}
}
//自定义线程类
public class MyThread extends Thread {
//定义指定线程名称的构造方法
public MyThread(String name) {
//调用父类的String参数的构造方法，指定线程的名称
super(name);
}
/**
* 重写run方法，完成该线程执行的逻辑
*/
@Override
public void run() {
for (int i = 0; i < 10; i++) {
  System.out.println(getName()+"：正在执行！"+i);
}
}
}

实现Runnable接口

实现Runnable接口, 并创建线程的步骤:

设计一个类, 实现Runnable接口, 并重写接口中的run方法, 在run方法中, 写上这个线程要处理的任务
创建Runnable实现类的对象, 并把这个对象作为Thread的target进行Thread对象的实例化, 这个Thread对象才是真正的线程对象
调用start方法, 来启动线程

public class Demo02 {
  public static void main(String[] args) {
    //创建线程执行目标类对象
    Runnable runn = new MyRunnable();
    //将Runnable接口的子类对象作为参数传递给Thread类的构造函数
    Thread thread = new Thread(runn);
    Thread thread2 = new Thread(runn);
    //开启线程
    thread.start();
    thread2.start();
    for (int i = 0; i < 10; i++) {
      System.out.println("main线程：正在执行！"+i);
    }
  }
}
//自定义线程执行任务类
public class MyRunnable implements Runnable{
  //定义线程要执行的run方法逻辑
  @Override
  public void run() {
    for (int i = 0; i < 10; i++) {
      System.out.println("我的线程：正在执行！"+i);
    }
  }
}

Callable

 class CallableThreadDemo implements Callable<Integer> {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CallableThreadTest ctt = new CallableThreadTest();
        FutureTask<Integer> ft = new FutureTask<>(ctt);
        new Thread(ft, "有返回值的线程").start();
        System.out.println("子线程的返回值" + ft.get());
    }
    @Override
    public Integer call() {
        int i;
        for (i = 0; i < 10; i += 2) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        return i;
    }
}

三种方式的不同点

实现Runnable接口的方式:

线程对应的任务类, 只是实现了Runnable接口, 不会对原有的继承关系产生影响
多个线程可以使用同一个Runnable接口实现类对象来实例化, 非常适合多个线程访问相同的资源情况
弊端:
1. 编程稍微复杂, 不直观
2. 如果需要获取到当前线程, 只能使用 Thread.currentThread() 来获取

继承Thread的方式:

编程简单, 直观,
如果需要访问当前线程, 直接用this即可, 也可以用 Thread.currentThread()
弊端:因为线程类继承自Thread类, 因此这个类不能再继承自其他类

实际上, 大多数需要用到多线程的情况, 都是使用的Runnable接口的方式来实现的 [推荐使用匿名内部类]

strart() 和 run() 的区别

start方法会开辟一个线程, 然后在这个新的线程中执行run中的逻辑

但是如果直接调用run(), 则表示需要在当前的线程中执行逻辑。

Runnable与Callable

相同点：都是接口，都可以编写多线程程序，都采用Thread.start()启动线程

不同点：Runnable没有返回值；Callable可以返回执行结果，是个泛型，和Future、FutureTask配合可以用来获取异步执行的结果

Callable接口的call()方法允许抛出异常；Runnable的run()方法异常只能在内部消化，不能往上继续抛

注：Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。

6.3 线程常用的方法

线程的名字

Thread thread = new Thread();
// 设置线程的名字
// 需要放到线程启动之前
thread.setName(name);
// 获取线程名字
thread.getName();

线程休眠 sleep

让一个指定的线程, 释放CPU时间片, 进入阻塞状态

休眠时间结束后, 线程进入就绪状态, 开始争抢时间片

Thread.sleep(500): 时间单位是毫秒

会有一个InterruptedException异常

设置线程优先级 priority

可以通过设置线程的优先级, 来修改某一个线程抢到时间片的概率, 优先级越高的线程, 抢到CPU时间片的概率越高, 但是这不意味者, 优先级高的线程一定能抢到时间片

默认情况下, 每一个线程的优先级, 都与创建他的线程优先级相同

优先级的范围 [0,10], 新建的线程, 优先级默认是5.

设置线程的优先级, 需要在线程启动(start)之前

thread.setPriority(2);

合并线程 join

在一个线程执行的过程中, 如果遇到了其他线程需要合并进来, 此时这个线程会释放CPU时间片, 去执行合并进来的线程. 合并进来的线程执行结束后, 再执行原来的逻辑.

特点:

线程合并, 当前线程一定会释放CPU时间片, 优先执行合并进来的线程
哪个线程需要合并到当前线程中, 就在当前线程中, 添加要合并的线程
合并之前, 线程一定要处于start

后台线程

一个隐藏起来的, 一直默默地在后面执行的线程, 直到程序结束

又叫做守护线程, 或者精灵线程,

JVM中的垃圾回收机制就是一个很典型的守护线程

如果所有的前台线程都死了, 后台线程会自动死亡

线程让步 yield

可以让当前的线程暂停, 但是不会进入阻塞, 只是从运行状态切换到了就绪状态, 完全可能出现的情况: 某一个线程yield暂停, 线程调度器又将其调度出来继续执行

实际上, 当某个线程使用yield让步后, 只有优先级与当前线程相同, 或者大于当前线程优先级的线程, 才有执行的机会

线程的生命周期

对于一个线程, 在被创建后, 不是立即就进入到了运行状态, 也不是一直处于运行状态, 在线程的声明周期中, 一个线程会在多种状态之间进行切换

new :创建状态, 线程被实例化, 但是还没有开始执行(start)

runnable: 就绪状态, 已经执行过start, 线程已经启动了, 只是没有抢到CPU时间片

running: 运行状态, 抢到了CPU时间片

blocked: 阻塞状态, 线程执行的过程中, 遇到一些特殊情况, 会进入阻塞状态. 阻塞中的线程, 是不能参数时间片的抢夺的 (不能被线程调度器调度)

dead: 死亡状态, 线程终止

正常死亡 : run方法中的代码执行结束

非正常死亡 : 强制使用stop方法停止这个线程

6.4 线程安全

临界资源问题：由于线程之间是资源共享的。如果有多个线程，同时对一个数据进行操作，此时这个数据会出现问题。

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

public class ThreadDemo {
  public static void main(String[] args) {
    //创建票对象
    Ticket ticket = new Ticket();
    //创建3个窗口
    Thread t1  = new Thread(ticket, "窗口1");
    Thread t2  = new Thread(ticket, "窗口2");
    Thread t3  = new Thread(ticket, "窗口3");
    t1.start();
    t2.start();
    t3.start();
  }
}
//模拟票
class Ticket implements Runnable {
  //共5票
  int ticket = 5;
  @Override
  public void run() {
    //模拟卖票
    while(true){
      if (ticket > 0) {
        //模拟选坐的操作
        try {
          Thread.sleep(1);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);
      }
    }
  }

如果有一个线程在访问一个临界资源，在访问之前，先对这个资源“上锁”，此时如果有其他的线程也需要访问这个临界资源，需要先查这个资源有没有被上锁，如果没有被上锁，此时这个线程可以访问这个资源；如果上锁了，则此时这个线程进入阻塞状态，等待解锁。

6.5 线程同步

同步代码段

// 同步代码段
// 小括号：就是锁
// 大括号：同步代码段，一般情况下，写需要对临界资源进行的操作
synchronized () {
}
// 关于同步锁：可以分成两种：对象锁、类锁
// 同步代码块中的锁对象可以是任意的对象；但多个线程时，要使用同一个锁对象才能够保证线程安全。

public class Ticket implements Runnable {
  //共10张票
  int ticket = 10;
  //定义锁对象
  Object lock = new Object();
  @Override
  public void run() {
    //模拟卖票
    while(true){
      //同步代码块
      synchronized (lock){
        if (ticket > 0) {
          //模拟电影选坐的操作
          try {
            Thread.sleep(10);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
          System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);
        }
      }
    }
  }
}

同步方法

// 使用synchronized关键字修饰的方法就是同步方法
// 将一个方法中所有的代码进行一个同步
// 相当于将一个方法中所有的代码都放到一个synchronized代码段中
// 同步方法的锁：
// 1. 如果这个方法是一个非静态方法：锁是this
// 2. 如果这个方法是一个静态方法：锁是类锁（当前类.class）
private synchronized void sellTicket() {
}

同步方法解决安全问题

public class Ticket implements Runnable {
  //共100票
  int ticket = 100;
  //定义锁对象
  Object lock = new Object();
  @Override
  public void run() {
    //模拟卖票
    while(true){
      //同步方法
      method();
    }
  }
//同步方法,锁对象this
  public synchronized void method(){
    if (ticket > 0) {
      //模拟选坐的操作
      try {
        Thread.sleep(10);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);
    }
  }
}

lock与unlock

就是一个类RenntrantLock

public class Ticket implements Runnable {
  //共10票
  int ticket = 10;
  //创建Lock锁对象
  Lock ck = new ReentrantLock();
  @Override
  public void run() {
    //模拟卖票
    while(true){
      //synchronized (lock){
      ck.lock();
        if (ticket > 0) {
          //模拟选坐的操作
          try {
            Thread.sleep(10);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
          System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);
        }
      ck.unlock();
      //}
    }
  }
}

公平锁：谁等的时间最长的线程，优先获取锁

public class Ticket implements Runnable {
  //共10票
  int ticket = 10;
  //创建Lock锁对象
  Lock ck = new ReentrantLock(true);
  @Override
  public void run() {
    //模拟卖票
    while(true){
      //synchronized (lock){
      ck.lock();
        if (ticket > 0) {
          //模拟选坐的操作
          try {
            Thread.sleep(10);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
          System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);
        }
      ck.unlock();
      //}
    }
  }
}

等待唤醒机制

多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。通过一定的手段使各个线程能有效的利用资源。而这种手段即—— 等待唤醒机制。

wait() 、notify() 、notifyAll()

wait(): 等待。使得当前的线程释放锁标记，进入等待队列。可以使当前的线程进入阻塞状态。

notify(): 唤醒，唤醒等待队列中的一个线程。

notifyAll(): 唤醒，唤醒等待队列中所有的线程。

wait和sleep的区别:

两个方法都可以使一个线程进入阻塞。
区别：wait方法会释放锁标记，sleep则不会释放锁标记。

package kaikeba;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ThreadDemo{
    public static void main(String[] args) {
        ResourceUnit r = new ResourceUnit();
        Producer p1 = new Producer(r, 1);
        Consumer c1 = new Consumer(r, 1);
        p1.start();
        c1.start();
    }
}
class ResourceUnit {
    private int contents;
    private boolean available = false;
    public synchronized int get() {
        while (available == false) {
            try {
                wait();
            }
            catch (InterruptedException e) {
            }
        }
        available = false;
        notifyAll();
        return contents;
    }
    public synchronized void put(int value) {
        while (available == true) {
            try {
                wait();
            }
            catch (InterruptedException e) {
            }
        }
        contents = value;
        available = true;
        notifyAll();
    }
}
class Consumer extends Thread {
    private ResourceUnit resourceUnit;
    private int number;
    public Consumer(ResourceUnit r, int number) {
        resourceUnit = r;
        this.number = number;
    }
    public void run() {
        int value = 0;
        for (int i = 0; i < 10; i++) {
            value = resourceUnit.get();
            System.out.println("消费者 #" + this.number+ " got: " + value);
        }
    }
}
class Producer extends Thread {
    private ResourceUnit resourceUnit;
    private int number;
    public Producer(ResourceUnit r, int number) {
        resourceUnit = r;
        this.number = number;
    }
    public void run() {
        for (int i = 0; i < 10; i++) {
            resourceUnit.put(i);
            System.out.println("生产者 #" + this.number + " put: " + i);
            try {
                sleep((int)(Math.random() * 100));
            } catch (InterruptedException e) { }
        }
    }
}

线程死锁(了解)

在解决临界资源问题的时候，我们引入了一个"锁"的概念。我们可以用锁对一个资源进行保护。实际，在多线程的环境下，有可能会出现一种情况：

假设有A和B两个线程，其中线程A持有锁标记a，线程B持有锁标记b，而此时，线程A等待锁标记b的释放，线程B等待锁标记a的释放。这种情况，叫做死锁。

6.6 线程池

线程池，其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。

Java通过Executors提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

创建并使用线程池

通常，线程池都是通过线程池工厂创建，再调用线程池中的方法获取线程，再通过线程去执行任务方法。

Executors：线程池创建工厂类

public static ExecutorService newFixedThreadPool(int nThreads)：返回线程池对象

ExecutorService：线程池类

Future<?> submit(Runnable task)：获取线程池中的某一个线程对象，并执行

Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用

 public static void main(String[] args) {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
            final int index = i;
            fixedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println(index);
                        Thread.sleep(2000);
                        System.out.println(Thread.currentThread().getName());
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            });
        }
    }

6. 多线程基础

6.多线程

6.1 多线程概念

6.2 创建线程的方式

6.3 线程常用的方法

6.4 线程安全

6.5 线程同步

6.6 线程池

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

6. 多线程基础

6.多线程

6.1 多线程概念

6.2 创建线程的方式

6.3 线程常用的方法

6.4 线程安全

6.5 线程同步

6.6 线程池

热门文章

最新文章

相关电子书