Java多线程(Thread)

多线程(Thread)

多任务：同时执行多个操作，比如：吃饭的时候完手机、边开车边打电话加挂点滴…

多线程：多条线路同时进行，多条执行路径，主线程和子线程并行交替执行，提高效率

程序.进程.线程

程序：是指令和数据的集合，其本身没有任何运行含义，是一个静态概念

进程(Process)：是执行程序的一次过程，它是一个动态概念一个进程可以包含多个线程，至少有一个线程，不然就没有存在的意义

线程：是cpu调度和执行的单位

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

线程实现

1. 继承Thread类
   • 自定义线程继承Thread类
   • 重写run()方法，编写线程执行体
   • 创建线程对象，调用start()方法启动线程
   • 启动线程：子类对象.start()
2. 实现Runnable接口
   • 定义一个类实现Runnable接口
   • 实现run()方法，编写线程执行体
   • 创建线程对象，调用start()方法启动线程
   • 启动线程：传入目标对象+Thread对象.start()
3. 实现Callable接口(了解)
   • 实现Callable接口，需要返回值类型
   • 重写call方法，需要抛出异常
   • 创建目标对象
   • 创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
   • 提交执行：Future result1 = ser.submit(1);
   • 获取结果：boolean r1 = result1.get();
   • 关闭服务：ser.shutdownNow();

注意：线程开启不一定立即执行，由cpu调度

静态代理

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

优点：

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

Lambda表达式

• 避免匿名内部类过多
• 去掉了一堆没有意义的代码，只留下核心的逻辑
• 属于函数式编程的概念

函数式接口：

• 任何接口，如果只包含唯一一个抽象方法，那么他就是一个函数式接口
• 对于函数式接口，我们可以通过lambda表达式来创建该接口的对象

package com.Thread.demo03;
/**
 * lambda表达式的使用
 *@author: zjx
 */
public class Demo01 {
    public static void main(String[] args) {
        //lambda表达式简化
//        Run like = (int a)->{
//            System.out.println("lambda表达式简化"+a);
//        };
//        like.lambda(1);
//      简化1：参数类型
//        Run like = (a)->{
//            System.out.println("lambda表达式简化"+a);
//        };
//        like.lambda(2);
        //简化2：括号
//        Run like = a->{
//            System.out.println("lambda表达式简化"+a);
//        };
//        like.lambda(3);
        //简化3：去掉花括号
        Run like = (a)-> System.out.println("lambda表达式简化"+a);

        like.lambda(4);
    }
}
//定义一个接口
interface Run{
    public void lambda(int a );
}

1. lambda表达式只能有一行代码的情况下才能简化为一行，如果有多行，那么就不能简化花括号
2. 前提是接口为函数式接口
3. 多个类型也可以去掉参数类型，要去掉都去掉，必须加上括号

线程状态

1. 创建状态
   • 线程对象一旦创建就进入到了新生状态
2. 就绪状态
   • 当调用satat()方法，线程立即进入就绪状态，但不意味着立即调度执行
3. 运行状态
   • 调度后进入运行状态，线程才真正执行线程体的代码块
4. 阻塞状态
   • 当调用sleep等停止方法时进入阻塞状态，阻塞事件解除后，重新进入就绪状态，等待cpu调度执行
5. 死亡状态
   • 线程中断或者结束，一旦进入死亡状态，就不能再次启动

线程方法：

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

线程停止

• 建议线程正常停止，不建议使用死循环
• 使用标识位强制停止线程
• 不要使用stop或者destroy等过时的方法或者JDK不建议使用的方法

线程休眠

• sleep(时间) 指定休眠的时间

• sleep时间达到后进入就绪状态

• sleep可以模拟网络延时，倒计时

• 每一个对象都有一个锁，sleep不会释放锁

线程礼让（Yield）

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

线程强制执行（Join）

Join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞

线程优先级

• getPriority() 获取优先级
• setPriority() 改变优先级

守护（daemon）线程

• 线程分为用户线程和守护线程
• 虚拟机必须确保用户线程执行完毕
• 虚拟机不用等待守护线程执行完毕
• setdaemon 设置一个守护线程

线程同步

多个线程操作同一资源

并发

• 同一个对象被多个线程同时操作

队列和锁

线程同步的形成条件时队列加锁，保证线程的安全性

锁机制（synchronized）

同步方法

使用synchronized关键字，它包括两种用法：

• synchronized方法
• synchronized块

public synchronized void method(int args){}

synchronized方法控制对"对象"的访问，每一个对象都有一把锁，每个synchronized方法都必须获得调用该方法对象的锁才能执行，否者线程阻塞，方法一旦执行，就

独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行

缺点：如果将一个大的方法申明为synchronized将会影响效率

方法里面需要修改的内容才需要锁，锁的太多，浪费资源

要锁变化的对象

死锁

多个线程互相抱着对方需要的资源，然后形成僵持

某一同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题

产生死锁四个必要条件：

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

只要破除其中任意一个或多个条件就可以避免死锁的发生

Lock(锁)

ReentrantLock（可重入锁）类实现了Lock，它拥有与synchronized相同的并发性和内存语义，它可以显式加锁、释放锁

相比synchronized来说，lock锁是显式的，性能更好，并且具有更好的扩展性，但只能锁代码块，synchronized有代码块锁和方法锁

线程协作

生产者消费者问题

线程通信

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

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

• wait() 表示线程一直等待，直到其他线程通知，会释放锁
• notify() 唤醒一个处于等待状态的线程

线程池

• 背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
• 思路：提前创建好多个线程，放入线程池中，使用时直接获取 ，使用完放回池中。可以避免频繁创建销毁、实现重复利用
• 好处：
  • 提高响应速度
  • 降低资源消耗
  • 便于线程管理
• ExecutorService：真正的线程池接口，常见子类ThreadPoolExecutor
• Executor：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

总结（创建线程的三种方式代码实现）

package com.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThreadNew {
    public static void main(String[] args) {
        new MyThread1().start();//继承Thread类的启动方法
        new Thread(new MyThread2()).start();//实现Runnable接口的启动方法
        FutureTask<Integer> futureTask = new FutureTask(new MyThread3());//实现Callable接口的启动方法
        new Thread(futureTask).start();

        try {
            Integer integer = futureTask.get();
            System.out.println(integer);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        }
    }
}
//创建线程的三种和方式
//1.继承Thread类
class MyThread1 extends Thread{
    @Override
    public void run() {
        System.out.println("MyThread1");
    }
}

//2. 实现Runnable接口
class  MyThread2 implements Runnable{
    public void run() {
        System.out.println("MyThread2");
    }
}
//3. 实现Callable接口
class MyThread3 implements Callable<Integer>{
    public Integer call(){
        System.out.println("MyThread3");
        return 100;
    }
}