Java多线程详解

多线程的3种创建方式

一、直接通过Thread线程类创建一个线程类对象—重写run方法

案例

package Thread1;
//多线程实现方式1---继承Thread类---调用start方法
//注意：子线程需要放在主线程执行语句之前启动
public class Stu1 {
    public static void main(String[] args) {
        Mythread t=new Mythread();
        t.start();
        for(int i=1;i<=5;i++){
            System.out.println("主线程执行："+i);
        }
    }
}

class Mythread extends Thread{

    @Override
    public void run() {
        for(int i=1;i<=5;i++){
            System.out.println("子线程执行："+i);
        }
    }
}

二、通过实现Runnable接口–重写run方法—创建任务对象，再创建线程对象—start（可实现继承功能）

案例

package Thread1;
//多线程创建方式2---任务类继承接口---线程类包任务类----start
public class Stu2 {
    public static void main(String[] args) {
//        创建任务对象
        Runnable runnable = new MyRun();
//        创建线程对象
        Thread thread = new Thread(runnable);
        thread.start();
        for(int i=1;i<=5;i++){
            System.out.println("主线程执行："+i);
        }
    }
}
class MyRun implements Runnable{
    @Override
    //子线程的需要执行的任务
    public void run() {
        for(int i=1;i<=5;i++){
            System.out.println("子线程执行："+i);
        }
    }
}

多种写法

package Thread1;
@SuppressWarnings("all")
public class Stu2_0 {
    //    匿名内部类形式---创建任务对象时就重写
    public static void main(String[] args) {
        Runnable task = new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.println("子线程1执行：" + i);
                }
            }
        };
        Thread t1 = new Thread(task);
        t1.start();

        //简化写法1--匿名内部类
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.println("子线程2执行：" + i);
                }
            }
        }).start();

//        简化写法2---Lamada表达式
        new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                System.out.println("子线程3执行：" + i);
            }
        }).start();


        for (int i = 1; i <= 5; i++) {
            System.out.println("主线程执行：" + i);
        }
    }
}

三、通过实现Callable接口—重写call方法----创建对象，再将该对象封装为FutureTask任务对象—进而创建线程对象–start（子线程种可以返回值）----通过FutureTask的get方法来获取

案例

package Thread1;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
//多线程创建方式3---包装Callable到FutureTask再利用任务对象做参创建线程对象
//优势：可在主线程中显示子线程执行后的返回值
public class Stu3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建一个callable对象
        Callable<String> callable=new Mycallable(100);
        //将callable封装为一个任务对象
        FutureTask<String> futureTask=new FutureTask<>(callable);
        //再交给一个线程对象
        Thread t1=new Thread(futureTask);
        t1.start();
        //任务对象的get方法获取线程执行完毕后的返回结果
        String s = futureTask.get();
        System.out.println(s);

    }
}
class Mycallable implements Callable<String>{
    private int n;
    public Mycallable(int n) {
        this.n = n;
    }
//    子线程具体操作：---call方法中
    @Override
    public String call() throws Exception {
        int sum=0;
        for(int i=1;i<=n;i++){
            sum+=i;
        }
        return "子线程求出了结果为："+sum;
    }
}

多线程的Thread的常用线程方法

thread.run();
thread.start();
thread.getName();//获取子线程的名字
thread.setName();//为线程设置名字----也可以在创建线程对象的时候用其重载的构造方法为线程设置名字 
Thread.currentThread();//返回执行这条语句的线程对象

Thread.sleep();//让当前线程休眠若干毫秒
thread.join();//保证线程的执行顺序--等thread线程执行完了才会接着往下执行其他线程
Thread.yield();//线程礼让，让正在运行的线程让出cpu资源
thread.setPriority();//线程设置优先级（1-10）优先级越高代表获取CPU资源的机会越多
thread.setDaemon(true);//将当前线程设置为守护线程，当只剩下守护线程时，程序结束

线程的安全问题（多个线程同时对同一个资源进行操作）—线程同步

解决方案总体思想：加锁----每次只允许一个线程加锁，加锁后才能进行访问，在访问完毕后会自动解锁，然后其他线程才能加锁进来

方式1：通过同步代码块进行
synchronized(同步锁){
    操作的资源~~~~~~
}
//通常情况下--实例方法中的同步锁设置为this
//静态方法中的同步锁设置为类名.class
//锁的设置一定要唯一---不然解决不了线程安全的问题

方式2：通过同步方法进行(内置锁----与同步代码块锁的种类选择方法一样)
    eg示例：
public synchronized void drawmoney(double money){

方式3：通过Lock接口的实例（ReentrantLock）对象来为资源加锁
lock/unlock

线程间的通信—生产者和消费者模式

//需要用到Object类的wait()/notify()方法
//需要用锁对象来调用
先唤醒别人，再让自己等待
void wait()//让当前线程等待并释放所占锁，直到另一个线程调用notify（）方法/notifyAll（）方法
void notify()//唤醒正在等待的单个线程
void notifyAll()//唤醒正在等待的所有线程

线程池（通过控制线程的数量和任务的数量来避免资源耗尽的风险）

key:重复利用已经执行完当前任务(Runnable/Callable)的线程执行接下来的任务

未来开发中核心线程数量的设置：
计算密集型任务：核心线程数量=CPU核心数+1
IO密集型任务：核心线程数量=CPU核心数2*

参数具体解释

//创建线程池对象的三种方式
//方式1：通过ExecutorService接口的实现类ThreadPoolExecutor构造器进行构造
//该构造器中存在7个参数
int corePoolSize;//指定线程池的核心线程数量
int maximumPoolSize;//指定线程池的最大线程数量
long keepAliveTime;//指定临时线程的存活时间
TimeUnit unit;//指定临时线程存活的时间的单位
BlockingQueue<Runnable> workQueue;//指定线程池的任务队列（等候创建临时线程来执行的任务队列---就是说：当任务队列占满了之后会创建临时线程）
ThreadFactory threadFactory;//指定线程池的线程工厂（创建线程的方式）
RejectExecutionHandler handler;//指定线程池的任务拒绝策略（线程均在忙，任务队列也满，新任务来时的处理方式）

//方式2：通过Executors类的静态方法获得不同特点的线程池对象（事实上---底层还是通过ThreadPoolExecutor创建的线程池对象）
//注意：有弊端
Exeutors.newFixedThreadPool(int nThreads);//创建固定数量的线程池（某个线程因为异常结束时，线程池会补充一个新的线程去代替他）
Exeutors.newSingleThreadExecutor();//创建只有一个线程的线程池对象（异常结束，线程池自动补充一个新线程）
Exeutors.newCachedThreadPool();//线程随任务的增加而增加，如果任务执行完毕且空闲60s则会被回收掉
Exeutors.newScheduledThreadPool(int corePoolSize);//创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务

使用Exeutors工具类开发时需要注意风险

任务拒绝的几种策略

线程池执行Runnable/Callable任务对象的具体方法

线程的生命周期及6种状态