Java多线程和JUC

最新推荐文章于 2024-05-16 10:23:10 发布

VIP文章研究了个寂寞

最新推荐文章于 2024-05-16 10:23:10 发布

阅读量210

点赞数 1

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/m0_51380540/article/details/120646145

版权

参考
【狂神说Java】多线程详解
 【狂神说Java】JUC并发编程最新版通俗易懂

多线程和JUC

一、多线程
二、JUC

一、多线程

1.1 线程简介

程序： 是为完成特定任务、用某种语言编写的一组指令的集合,是一段静态的代码（程序是静态的）
进程： 是程序的一次执行过程。正在运行的一个程序，进程作为资源分配的单位，在内存中会为每个进程分配不同的内存区域。
线程： 进程可进一步细化为线程，是一个程序内部的一条执行路径。若一个进程同一时间并行执行多个线程，就是支持多线程的。线程是CPU调度和执行的单位

注意：很多多线程是模拟出来的，真正的多线程是指多个CPU。如果是模拟出来的多线程，即在同一个CPU下，同一时间CPU只能执行一段代码，因为切换很快就有同时执行的错觉

并行和并发
并行：多个CPU同时执行多个任务
并发：一个CPU“同时”执行多个任务（采用时间片切换）

核心概念

线程就是独立执行的路径

在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程、GC线程

main()称之为主线程，为系统的入口，用于执行整个程序

在一个进程中，如果开劈了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序不能人为干预

对同一份资源操作时，会存在抢资源的问题，需要加入并发控制

线程会带来额外开销，如CPU调度时间，并发控制开销

每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

1.2 线程的创建

线程不一定立即执行，CPU安排调度

第一种：继承Thread类
第一步：自定义线程类继承Thread类
第二步：重写run()方法，编写线程执行体
第三步：创建线程对象，调用start()方法启动线程

第二种：实现Runnable接口
第一步：自定义线程类实现Runnable接口
第二步：重写run()方法，编写线程执行体
第三步：创建线程对象，通过线程对象调用start()方法启动线程
（推荐使用，避免了单继承的局限性，方便一个对象被多个线程使用）

第三种：实现Callable接口 （现阶段了解）
第一步：实现Callable接口，需要返回值
第二步：重写call方法，需要抛出异常
第三步：创建目标对象
第四步：创建执行服务：ExecutorServices ser = Executors.newFixedThreadPool(3);
第五步：提交执行：Future< Boolean > result1 = ser.submit(t1)
第六步：获取结果：boolean r1 = result.get()
第七步：关闭服务：ser.shutdownNow();

扩展

扩展1：静态代理

https://www.cnblogs.com/tele-share/p/9464295.html

静态代理应用：
对比以实现Runnable接口的形式创建多线程,可以发现,代理角色Thread类不需要我们创建,我们只需要写委托对象
实现Runnable接口.把委托对象的引用传递给Thread,借助Thread对象来开启线程即可

扩展2：lambda表达式
优点：
避免匿名内部类定义过多，简洁

Lambda演变方式：
1、前提：定义一个函数式接口(接口中只包含一个抽象方法)，对于函数式接口可以通过Lambda表达式创建该接口的对象
2、实现类，创建对象，对象调用方法
3、静态内部类，创建对象，对象调用方法
4、局部内部类，创建对象，对象调用方法
5、匿名内部类，没有类的名称，必须借助接口或者父类
6、lambda表达式（用于函数式接口）

lambda表达式应用：
Runnable接口中只有public abstract void run();方法，符合函数式接口，可以使用Lambda表达式创建该接口的对象，之后传入Thread中(要传入Runnable实现类)

new Thread( () -> System.out.println("多学习多线程。。")).start();

1.3 线程状态

五大状态：
在这里插入图片描述

1.4 线程常用方法

start()：启动当前线程，表面上调用start方法，实际在调用线程里面的run方法
run()：线程类继承 Thread类或者实现Runnable接口的时候，都要重新实现这个run方法，run方法里面是线程要执行的内容
currentThread :Thread类中一个静态方法：获取当前正在执行的线程
setName：设置线程名字
getName：读取线程名字

stop方法：
过期方法，不建议使用
建议线程正常停止
建议使用标志位，设置flag

//自己编写stop方法
public class Test07 implements Runnable{
   
    //设置停止的标志位
    private boolean flag = true;

    @Override
    public void run() {
   
        int i = 0;
        while (flag){
   
            System.out.println("run方法"+i++);
        }
    }

    //使用标志位flag，自己设置stop()方法
    public void stop(){
   
        this.flag = false;
    }

    public static void main(String[] args) {
   
        Test07 t = new Test07();
        new Thread(t).start();

        for (int i = 0; i < 100; i++) {
   
            System.out.println("main--"+i);
            if (i == 90){
   
                t.stop();
                System.out.println("该线程停止了");
            }
        }
    }
}

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

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

//测试sleep，倒计时，打印系统时间
public class Test08 {
   

    public static void main(String[] args) {
   
        //打印系统时间
        DateFormat df = new SimpleDateFormat("HH:mm:ss");
        while (true){
   
            Date d = new Date();
            System.out.println(df.format(d));
            try {
   
                Thread.sleep(1000);
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
        }

        /*十秒倒计时
        try {
            tenDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }*/
    }

    //十秒钟倒计时
    public static void tenDown() throws InterruptedException {
   
        int i = 10;
        while (true){
   
            System.out.println(i--);
            Thread.sleep(1000);
            if (i<=0){
   
                break;
            }
        }
    }
}

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

//测试礼让yield
public class Test09 {
   
    public static void main(String[] args) {
   
        MyYield my = new MyYield();
        
        new Thread(my,"a").start();
        new Thread(my,"b").start();
    }
}


class MyYield implements Runnable{
   
    @Override
    public void run() {
   
        System.out.println(Thread.currentThread().getName()+"开始执行");
        Thread.yield();//线程礼让
        System.out.println(Thread.currentThread().getName()+"执行结束");
    }
}

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

//测试join
public class Test10 implements Runnable{
   
    @Override
    public void run() {
   
        for (int i = 0; i < 1000; i++) {
   
            System.out.println("VIP来了"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
   
        Test10 t = new Test10();
        Thread thread = new Thread(t);
        thread.start();

        for (int i = 0; i < 100; i++) {
   
            if (i==50){
   
                thread.join();
            }
            System.out.println("main--"+i);
        }
    }
}

Thread.State 查看线程状态

//观测线程的状态
public class Test11 {
   
    public static void main(String[] args) throws InterruptedException {
   
        Thread thread = new Thread(() -> {
   
            for (int i = 0; i < 5; i++) {
   
                try {
   
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
            }
            System.out.println("----------");
        });

        Thread.State state = thread.getState();
        System.out.println(state);

        thread.start();
        state = thread.getState();//更新状态
        System.out.println(state);

        while (state != Thread.State.TERMINATED){
   
            Thread.sleep(100);
            state = thread.getState();//每次都要更新状态
            System.out.println(state);
        }
    }
}

设置线程优先级
Thread.MIN_PRIORITY = 1
Thread.MAX_PRIORITY = 1
Thread.NORM_PRIORITY = 1
getPriority()，serPriority(int XXX)

//测试优先级
public class Test12 {
   
    public static void main(String[] args) {
   
        System.out.println(Thread.currentThread().getName()+"----"+Thread.currentThread().getPriority());//主程序的
        MyPriority myPriority = new MyPriority();

        Thread t1 = new Thread(myPriority,"t1");
        Thread t2 = new Thread(myPriority,"t2");
        Thread t3 = new Thread(myPriority,"t3");
        Thread t4 = new Thread(myPriority,"t4");
        Thread t5 = new Thread(myPriority,"t5");


        //先设置优先级，再启动
        t1.setPriority(Thread.MAX_PRIORITY);
        t1.start();

        t2.setPriority(1);
        t2.start();

        t3.setPriority(2);
        t3.start();

        t4.setPriority(1);
        t4.start();

        t5.setPriority(10);
        t5.start();
    }
}

class MyPriority implements Runnable{
   
    @Override
    public void run() {
   
        System.out.println(Thread.currentThread().getName()+"----"+Thread.currentThread().getPriority());
    }
}

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

Thread thread = new Thread(god);
thread.setDaemon(true);//true表示守护线程，默认false表示用户线程
thread.start();

1.4 线程同步(线程安全问题)

多线程操作同一资源
并发：同一个对象被多个线程同时操作
线程同步其实就是一种等待机制 / 排队

队列+锁 才能保证线程同步的安全性
synchronized

不安全的例子

//线程不安全的集合
import java.util.ArrayList;
import java.util.List;

//ArrayList不安全的集合
public class Test13 {
   
    public static void main(String[] args) {
   
        List list = new ArrayList();
        for (int i = 0; i < 10000; i++) {
   
            new Thread(()->{
   
                list.add(Thread.currentThread().getName());
            }).start();
        }