Java并发

package JUCDemo.demo1;
public class myThread extends Thread{
    @Override
    public void run() {
        for (int i = 0;i < 10;i ++){
            System.out.println(getName() + "Hello Thread");
        }
    }
}

3.创建对象启动线程

package JUCDemo.demo1;
public class demo1 {
    public static void main(String[] args) {
        /*
        1.定义一个类继承Thread类
        2.重写Run方法
        3.创建子类对象并启动线程
        */

        myThread t1 = new myThread();
        myThread t2 = new myThread();
        myThread t3 = new myThread();
        t1.setName("t1");
        t2.setName("t2");
        t3.setName("t3");

        t1.start();
        t2.start();
        t3.start();
    }
}

优点：编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。

缺点：线程类已经继承了Thread类，所以不能再继承其他父类。

实现Runnable接口

1.自己定义一个类实现Runnable接口

2.重写run方法

package JUCDemo.demo2;
public class myRunnable implements Runnable{

    @Override
    public void run() {
        //获取当前线程的对象
        Thread t = Thread.currentThread();
        for (int i = 0; i < 10; i++) {
            System.out.println(t.getName()+"线程执行");
        }
    }
}

3.创建自己类的对象

4.创建一个Thread类的对象，并开启线程

package JUCDemo.demo2;
public class demo2 {
    public static void main(String[] args) {
        myRunnable myRunnable = new myRunnable();
        Thread t1 = new Thread(myRunnable);
        Thread t2 = new Thread(myRunnable);
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        t2.start();
    }
}

优点：没有继承Thread类，所以可以继承其他的类，适合多线程访问同一资源的情况，将cpu和数据分开，形成清晰的模型，较好的体现了面向对象的思想

缺点：编程相对复杂，要想获得当前线程对象，需要使用Thread.currentThread()方法。

实现Callable接口与FutureTask类

1.实现Callable接口

其中我们要制定返回的参数值类型，这里使用String。

2.重写call方法并return线程执行的结果

package JUCDemo.demo3;
import java.util.concurrent.Callable;
//1.实现Callable接口
public class myCallable implements Callable<String> {
    int n = 0;
    public myCallable(int n) {
        this.n = n;
    }
    //2.重写Call方法
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 0; i < n; i++) {
            sum = sum + i;
        }
        return "线程执行1到" + n + "的和是:" + sum;
    }
}

3.创建Callable对象

4.把Callable对象封装成FutureTask对象

FutureTask

由于Callable对象是无法扔给Thread的，所以我们要通过封装成FutureTask对象的形式把我们的Callable对象交给Thread。

我们通过FutureTask的源码可以发现，他是实现了Runnable接口的。

5.把任务交给Thread类

6.获取执行的结果

package JUCDemo.demo3;

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

public class demo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //3.创建Callable对象
        Callable<String> callable = new myCallable(100);
        //4.把Callable对象封装成一个FutureTask对象（任务对象）
        //FutureTask的作用
        //    是一个任务对象，实现了Runnable接口
        //    可以在任务结束之后，调用get方法获取执行完毕的结果
        FutureTask<String> f1 = new FutureTask<>(callable);
        //5.把任务对象交给Thread对象
        new Thread(f1).start();
        //6.获取线程执行完毕的结果
        String rs = f1.get();
        System.out.println(rs);
    }
}

优点

线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。可以在线程执行完毕后去获得线程执行完毕的结果。

缺点

编码复杂。

Thread常用方法

Thread提供常用方法	说明
pulic void run()	线程的任务方法
public void start()	启动线程
public String getName()	获取当前线程的名称，默认是Thread-索引
public void setName(String name)	为线程设置名字
public static Thread currentThread()	获取当前执行的线程对象
public static void sleep（long time）	让线程休眠
public final void join（）	调用当前这个方法让线程先执行完

Thread常用构造器

Thread常用构造器	说明
public Thread（String name）	可以为当前线程指定名称
public Thread（Runnable target）	封装Runnable对象为线程对象
public Thread （Runnable target，String name）	封装Runnable对象为线程对象，指定名称

为什么启动线程要调用start（）方法而不是直接调run（）方法

new 一个 Thread，线程进入了新建状态; 调用start() 会执行线程的相应准备工作，然后自动执行 run() 方法的内容，（调用 start() 方法，会启动一个线程并使线程进入了就绪状态，当分配到时间片后就可以开始运行了。）这是真正的多线程工作。
直接执行 run() 方法，会把 run 方法当成一个 main 线程下的普通方法去执行，并不会在某个线程中执行它，所以这并不是多线程工作。 调用 start 方法方可启动线程并使线程进入就绪状态，而 run 方法只是 thread 的一个普通方法调用，还是在主线程里执行。

线程安全

Java线程安全问题是指在多线程环境下，多个线程同时访问共享资源时可能导致的数据不一致、数据损坏或程序异常等问题。这种问题可能发生在并发读写共享变量、共享数据结构或共享资源的情况下。

举个栗子，小明和小红共有一个银行账户，里面有100块钱。

当小明和小红都执行取钱操作的时候，系统会创建两个线程分别给小明和小红。

取钱分为两步，第一步判断余额，第二步账号减少余额并取出100。

当小明的线程判断完余额=100但是没有执行减少余额这个步骤时，小红线程进行了余额判断，那么系统便会分别给小明和小红100，这就是线程安全问题。

解决线程安全一般有三个方法，分别是：

线程同步

思想

让多个线程实现先后依次访问共享资源，这样就解决了线程安全问题。

常见方案

加锁：每次只允许一个线程加锁，加锁之后才能访问共享资源，访问完毕之后释放锁，然后其他线程才能再进行加锁操作并访问共享资源。

即，小明这个线程进入判断余额操作之后，会对判断余额上一把锁，上锁时小红线程就无法进行判断余额操作进入等待状态，只有当小明取钱完毕后小红才能进行余额判断。

同步代码块

作用

使用synchronized关键字把共享资源的核心代码块上锁，以保证此线程的安全。

原理

每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行。

锁对象的使用规范

建议使用共享资源作为锁对象，对于实例方法建议this作为锁对象。
对于静态方法建议使用字节码（类名.class）对象作为锁对象。

同步方法

作用

使用synchronized关键字把共享资源的核心方法上锁，以保证此线程的安全。

底层原理

同步方法也是有隐藏式锁对象的，只是锁的范围是整个方法代码。
如果方法时实例方法：同步方法默认this作为锁对象。
如果方法时静态方法：同步方法默认类名.class作为锁的对象。

Lock锁

Lock锁时jdk5开始提供的一个新的锁定操作，通过它可以创建出锁对象来进行加锁和解锁，更灵活、更强大、更方便。
Lock是接口，不能直接实例化，需要使用它的实现类ReentrantLock来构建Lock锁对象。

线程通信

什么是线程通信

当多个线程共同操作共享的资源时，线程之间通过某种方式互相告知自己的状态，以相互协调，避免无效的资源争夺。

生产者与消费者模型

生产者线程负责生产数据。

消费者线程负责消费生产者线程生产的数据。

生产者生产完数据应该等待自己，通知消费者消费。消费者消费完数据也应该等待自己，再通知生产者生产。

等待和唤醒方法

方法名称	说明
void wait()	让当前线程等待并释放所占锁，知道另一个线程调用notify方法或notifyAll方法
void notify()	唤醒正在等待的单个线程
void notifyAll()	唤醒所有正在等待的线程

线程池

什么是线程池

线程池就是一个可以复用线程的技术。

不使用线程池的问题

用户每发起一个请求，后台就要创建一个新线程来处理，下次新任务来了肯定又要创建新的线程来处理，而创建新的线程的开销是很大的，并且请求过多时，肯定会产生大量线程出来，这样会严重影响系统的性能。

线程池组成

线程池管理器（ThreadPoolExecutor）：线程池管理器是线程池的核心组件，负责创建、管理和调度线程。
工作线程（WorkQueue）：工作队列用于存储等待执行的任务。当有新的任务提交给线程池时，线程池将任务放入工作队列中，并由线程池中的线程按照一定的策略从队列中取出任务进行执行。
线程池线程（Worker Thread）：线程池中的线程是执行任务的工作单元。任务队列中的线程对象必须是实现了Runnable接口或者Callable接口的才能进入任务对列。