java找工作之多线程

多线程

线程：java.Thread

线程简介

想要了解多线程首先就要了解什么是单线程，单线程运行程序时，如果调用了其他方法，会将其他方法加入到当前的线程中，只有主线程一条执行路径，而多线程运行程序时会有多条执行路径，主线程和子线程并行交替执行。

在这里还要引入一个重要的概念：进程。什么是进程？在操作系统中运行的程序就是进程，一个进程中可以有多个线程，比如我们在看一个视频时有声音、有字幕、有图像，这些内容同时包含在一个进程之中。

与进程相对应的就是程序，程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。而进程则是在执行程序的一次执行过程，它是一个动态的概念，是系统资源分配的单位，进程表明了程序的资源位置，而线程才真正代表着cpu的运行。通常在一个进程中可以包含多个线程，线程是CPU调度和执行的单位。

真正的多线程是指有多个cpu（多核），如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以有同时执行的错觉。

核心概念

• 线程就是独立的执行路径
• 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程
• main（）称之为主线程，是程序的入口，用于执行整个程序
• 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能认为被干预的。
• 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制。
• 线程会带来额外的开销，如cpu调度时间，并发控制开销。
• 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。

线程创建

线程创建有三种方式。

• Thread（class）：继承Thread类
• Runnable接口：实现Runnable接口
• Callable接口：实现Callable接口

参考jdk文档https://tool.oschina.net/apidocs/apidoc?api=jdk-zh

继承Thread类

自定义一个类，使这个类继承Thread类，重写Thread的run（）方法，编写线程执行体，创建线程对象，调用start（）方法启动线程。多个线程交替执行，线程不一定立即执行，CPU调度安排。

public class startThread1 extends Thread{
   //线程入口点 
    @Override
    public void run（）{
        //线程体
        for (int i=0;i<20;i++)
            System.out.println("我在听课")；
    }
}
//这种情况下是多线程，两种线程的执行体交替执行
public static void main（String[] args）{
    //main线程，主线程
    //创建线程对象
    startThread1 t = new StartThread1（）;
    //调用start方法开启线程
    t.start();
    
      for (int i=0;i<20;i++)
            System.out.println("我是主线程")；
}

//这种情况下是单线程，按程序顺序执行
public static void main（String[] args）{
    //main线程，主线程
    //创建线程对象
    startThread1 t = new StartThread1（）;
    //调对象的run方法
    t.run();
    
      for (int i=0;i<20;i++)
            System.out.println("我是主线程")；
}

实现Runnable接口(推荐使用)

首先定义一个类实现Runnable接口，实现run（）方法，编写线程1执行体，创建线程对象1，调用start（）方法启动线程。

public class Test implement Runnable{
     @Override
    public void run（）{
        //线程体
        for (int i=0;i<20;i++)
            System.out.println("我在听课")；
    }
}
public static void main（String[] args）{
    //创建Runnable接口的实现类对象
    Test test = new Test（）;
    //创建线程对象来开启我们的线程，代理
    Thread thread = new Thread（test）;
    thread.start();
}

对比

• 继承Thread类
  • 子类继承Thread类
  • 启动线程：子类对象.start()
  • 不建议使用：避免OOP单继承1111局限性
• 实现Runnable接口
  • 实现接口Runnable具有多线程能力
  • 启动线程：传入目标对象+Thread对象.start（）
  • 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

实现Callable接口

实现步骤如下：

• 实现Callable接口，需要返回值类型
• 重写call方法，需要抛出异常
• 创建目标对象
• 创建执行服务：ExecutorService ser = Exectors.newFixedThreadPool(1);
• 提交执行:Future result1 = ser.submit(t1);
• 获取结果:boolean r1 = result.get();
• 关闭服务:ser.shutdownNow();

public class TestCallable implements Callable{
    @Override
    public Boolean call(){
         System.out.println("我在听课")；
             return ture;
    }
}
public static void main（String[] args）{
    Test t1 = new TestCallable();
     Test t2 = new TestCallable();
    //创建执行服务
    ExecutorService ser = Exectors.newFixedThreadPool(1);
    //提交执行
    Future<Boolean> r1 = ser.submit(t1);
    Future<Boolean> r2 = ser.submit(t2);
    //获取结果
    boolean rs1 = r1.get();
     boolean rs2 = r2.get();
    //关闭服务
    ser.shutdownNow();
}

静态代理与Thread

模式总结：

• 真实对象和代理对象都要实现同一个接口
• 代理对象要代理真实对象

好处：

• 代理对象可以做很多真实对象做不了的事情
• 真实对象可以专注做自己的事情

Thread就是代理对象，Runnable是真实对象，Runnable重写run方法，Thread类中调用Runnable接口实现类，Thread调用run方法，实际上实现的还是Runnable接口实现类的方法体。

Lamda表达式

避免匿名内部类定义过多，格式如下：

（params）->expression[表达式]

（params）->statement[语句]

（params）->{statements}

上述实现Runnable接口可以用如下代码简化
new Thread (()->System.out.println("多线程学习")).start

线程状态

线程有五大状态，创建状态，阻塞状态，死亡状态，就绪状态和运行状态。

• 创建状态：new一个新线程就进入创建状态
• 就绪状态：当启动了一个线程后就进入了就绪状态，或者当运行状态释放CPU资源后或者阻塞状态解除后进入就绪状态
• 运行状态：就绪状态获得cpu资源后就进入运行状态
• 阻塞状态：在运行状态时，等待用户输入线程休眠（sleep方法）等
• 死亡状态：在运行状态时，线程自然执行完毕，外部干涉中止线程

Thread t = new Thread()线程对象一旦创建就进入到了新生状态，当调用start方法，线程立即进入就绪状态，但不意味立即调度执行。获得cpu调度后，线程进入运行状态，此时线程才真正执行线程体的代码块。当调用sleep，wait或同步锁定时，线程进入阻塞状态，就是代码不往下执行，阻塞事件解除后，重新进入就绪状态，等待cpu调度执行。线程中断或者结束，一旦进入死亡状态，就不能再次启动。

####线程方法

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

线程的停止

停止线程不推荐使用JDK提供的stop、destory方法，这两种方法已经废弃，推荐线程自己停下来，建议使用一个标志位进行终止变量，当flag=false，则终止线程运行。

public class TestStop implements Runnable{
    //1.线程中定义线程体所使用的标识
    private flag = true;
    
    @Override
    public void run(){
    //2.线程体使用该标识
        while(flag){
            System.out.println("run...Thread");
        }
}
    //3.对外提供方法改变标识
    public void stop(){
        this.flag=false;
    }
}

线程休眠

• sleep（时间）指定当前线程阻塞的毫秒数
• sleep存在异常InterruptedExeption
• sleep时间达到后线程进入就绪状态
• sleep可以模拟网络延时，倒计时等
• 每一个对象都有一个锁，sleep不会释放锁

模拟网络延时可以放大问题的发生性，防止某一线程运行过快拿走所有资源。

线程礼让

• 礼让线程，让当前正在执行的线程暂停，但不阻塞
• 将线程从运行状态转为就绪状态
• 让cpu重新调度，礼让不一定成功，看cpu心情

礼让函数：Thread.yield（）

线程强制执行

• join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
• 可以想象成插队

函数：Thread.join（）

观测线程状态

Thread.State

• NEW
  至今尚未启动的线程处于这种状态。
• RUNNABLE
  正在 Java 虚拟机中执行的线程处于这种状态。
• BLOCKED
  受阻塞并等待某个监视器锁的线程处于这种状态。
• WAITING
  无限期地等待另一个线程来执行某一特定操作的线程处于这种状态。
• TIMED_WAITING
  等待另一个线程来执行取决于指定等待时间的操作的线程处于这种状态。
• TERMINATED
  已退出的线程处于这种状态。

在给定时间点上，一个线程只能处于一种状态。这些状态是虚拟机状态，它们并没有反映所有操作系统线程状态。

线程优先级

• java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器1按照优先级决定应该调度哪个线程来执行
• 线程的优先级从1到10
  • Thread.MIN_PRIORITY=1;
  • Thread.MAX_PRIORITY=10;
  • Thread.NORM_PRIORITY=5;
• 使用以下方式改变或获取优先级
  • getPriority（）
  • setPriority（int xxx）

守护线程

• 线程分为用户线程和守护线程
• 虚拟机必须确保用户线程执行完毕
• 虚拟机不用等待守护线程执行完毕
• 如后台记录操作日志，监控内存，垃圾回收等

正常线程是用户线程，设置为守护线程的函数为thread.setDaemon（true）

线程同步

线程同步即多个线程操作同一个资源

并发：同一个对象被多个线程同时操作

线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。

队列和锁

线程同步需要队列加锁。

• 由于同一进程的多个线程共享同一块存储空间，在带来方便的同时也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制，当一个线程获得对象的排它锁，独占资源，其他线程必须等待使用后释放锁即可。
• 存在以下问题
  • 一个线程持有锁会导致其他所有需要此锁的线程挂起
  • 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题
  • 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题

死锁

多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，这就是死锁。

产生死锁的四个必要条件

• 互斥条件：一个资源每次只能被一个进程使用
• 请求与保持条件：一个进程因请求资源而阻塞时，对已经获得的资源保持不放
• 不剥夺条件：进程已经获得的资源，在未使用完之前，不能强行剥夺
• 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系

只要想办法破坏其中的一个或多个条件就可以避免死锁发生

生产者消费者问题

生产者生产东西，消费者消费东西， 这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件。

• 对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，又需要马上通知消费者消费。
• 对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费。
• 在生产者消费者问题中，仅有synchronized是不够的
  • synchronized可以阻止并发更新同一个共享资源，实现了同步
  • synchronized不能用来实现不同线程之间的消息传递

java提供了几个方法解决线程之间的通信问题

方法名	作用
wait()	表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁
wait(long timeout)	指定等待的毫秒数
notify()	唤醒一个处于等待状态的线程
notifyAll()	唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度

线程池

提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中，避免频繁创建销毁，实现重复利用。

便于线程管理：

• corePoolSize：核心池的大小
• maximumPoolSize：最大线程数
• keepAliveTime：线程没有任务时最多保持多长时间后会终止

使用线程池

JDK 5.0起提供了线程池相关API：ExecutorService和Executors

ExecutorService：真正的线程池接口，常见子类ThreadPoolExecutor

• void execute(Runnable command):执行任务/命令，没有返回值，一般用来执行Runnable
• Futuresubmit(Callable task):执行任务，有返回值，一般又来执行callable
• void shutdown():关闭连接池

Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池