2022-08-02 第五小组顾祥全学习笔记 day26-JavaSE-多线程-基础部分

激进的韭菜

已于 2022-08-04 19:40:51 修改

阅读量207

点赞数 1

分类专栏： JavaSE学习笔记文章标签：学习 java 后端开发语言

于 2022-08-02 23:57:01 首次发布

本文链接：https://blog.csdn.net/weixin_56090951/article/details/126116435

版权

JavaSE学习笔记专栏收录该内容

26 篇文章 1 订阅

订阅专栏

多线程

程序、进程、线程

程序：程序是指令和数据的有序集合(静态概念)
进程：进程是执行程序的一次执行过程(动态概念),是系统资源分配的单位。
线程：线程是进程的一个执行单元/执行场景，线程是CPU调度和执行的单位，通常一个进程中可以包含若干个线程。

对于Java程序来说，使用java.exe命令时，会启动JVM，JVM就是一个进程，JVM会启动一个线程调用main方法，以及再启动一个垃圾回收线程负责看守。(每开启一个线程就会再内存中开辟一块栈空间)

并发与并行

并发：在宏观上，线程之间看起来是在同一个时间点上执行，可以给人一种线程并行的感觉，实际上并非如此，底层是线程之间抢占时间片(线程之间交替执行)
并行：线程之间是可以再同一个时间点上执行

线程分类

用户线程(main)
守护线程(后台线程)

守护线程为i用户线程体提供服务，仅在用户线程运行时才需要
守护线程对于后台支持任务非常有用
垃圾回收就是一种守护线程
设置守护线程：
在任何线程继承创建他的线程守护继承状态，由于主线程是用户线程因此在main方法内启动的任何线程默认都是守护线程

Thread类

构造方法在这里插入图片描述
常用方法

方法	功能
void setPriority(int)	更改当前线程优先级优先级(1~10)，默认是5
int getPriority(int)	获取当前线程优先级
static void sleep(long)	指定当前线程睡眠的毫秒数
void join()	线程插队，被插入的线程需要等待插入线程的终止才能继续执行
static void yield()	礼让线程，让当前线程释放CPU资源，和其他就绪线程一起竞争CPU资源，按照优先级高低获取资源，同级随机。(将礼让线程从运行状态转换成就绪状态让CPU重新调度)
void setDeamon(boolean)	将当前线程设置为守护线程

创建线程

编写一个类，继承java.lang.Thread，重写run方法

package com.jsoft.thread;

/**
 * 创建一个类，让其继承Thread，并重写run()
* @author guxiangquan
* @date 2022/8/2
*/

public class ThreadDemo01 {
    public static void main(String[] args) {
        // start()方法调用会在内存中开辟一块栈空间(线程)，并调用run()
        new MyThread1().start();
    }
}

class MyThread1 extends Thread {
    @Override
    public void run() {
        System.out.println("MyThread1线程执行");
    }
}

编写一个类，实现java.lang.Runnable接口

package com.jsoft.thread;

/**
 * 创建一个类，让其实现Runnable接口
* @author guxiangquan
* @date 2022/8/2
*/

public class ThreadDemo02 {
    public static void main(String[] args) {
        // 1.正常的方式实现
        new Thread(new MyThread2()).start();

        // 2.匿名内部类的方式实现
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Thread2线程运行(匿名内部类)");
            }
        }).start();

        // 3.Lambda表达式(箭头函数)实现
        new Thread(() -> 
        	System.out.println("Thread2线程运行(Lambda表达式)")).start();

    }
}

class MyThread2 implements Runnable {
    @Override
    public void run() {
        System.out.println("Thread2线程执行(正常方式)");
    }
}

编写一个类，实现java.util.concurrent.Callable接口

package com.jsoft.thread;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

/**
 * 通过实现Callable接口(Java5新特性)创建线程
* @author guxiangquan
* @date 2022/8/2
*/

/*
* Callable优势
*   1. 支持泛型
*   2. 可以有返回值(泛型类型)
*   3. 可以抛出异常
* */
public class ThreadDemo03 {

    public static void main(String[] args) {
        // 1.正常方式实现
        Callable myThread3 = new MyThread3();
        // 需要通过FutureTask对象作为容器，才能实例化Thread对象
        FutureTask<String> stringFutureTask = new FutureTask<String>(myThread3);
        Thread thread = new Thread(stringFutureTask);
        thread.start();

        // 2.匿名内部类实现
        new Thread(new FutureTask<String>(new Callable<String>() {
            @Override
            public String call() throws Exception {
                System.out.println("Thread2线程运行(匿名内部类方式)");
                return null;
            }
        })).start();

        // 3.Lambda表达式实现
        new Thread(new FutureTask<String>(() -> {
            System.out.println("Thread2线程运行(Lambda表达式方式)");
             return "Thread2线程运行(Lambda表达式方式)";
         })).start();


    }
}

class MyThread3 implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println("Thread2线程运行(正常方式)");
        return  "Thread2线程运行(正常方式)";
    }
}

线程的生命周期

在这里插入图片描述

线程停止

不推荐使用JDK提供的stop()，destroy()方法(==已废弃==)
推荐让线程自己停下来，建议使用一个标志位进行终止变量。

线程休眠、线程等待、线程唤醒

线程休眠

使用Thread类的静态方法——static void sleep(long)

线程通信

线程等待

使用Object类的实例方法(即所有对象都有的实例方法)——native void wait()

线程唤醒

使用Object类的实例方法(即所有对象都有的实例方法)——native void notify()/notifyAll()

生产者消费者

使用线程通信(wait和notify)实现

package com.jsoft.homework;



// 奶箱
public class Box {
    private int milkCount = 0;   // 牛奶数

    public int getMilkCount() {
        return milkCount;
    }

    public void setMilkCount(int milkCount) {
        this.milkCount = milkCount;
    }

    public Box(int milkCount) {
        this.milkCount = milkCount;
    }

    public static void main(String[] args) {
        Box box = new Box(0);
        new Thread(new Producer(box),"生产者").start();
        new Thread(new Customer(box),"消费者").start();
    }
}



// 生产者
class Producer implements Runnable{
    private Box box;

    public Producer(Box box) {
        this.box = box;
    }

    @Override
    public void run() {
        // 一直生产
        while(true) {
            synchronized (box) {
                // 大于0时不成产，消费
                if(box.getMilkCount() > 0) {
                    try {
                        box.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 小于0生产
                box.setMilkCount(box.getMilkCount()+1);
                System.out.println(Thread.currentThread().getName() + "--生产1个剩余：-->" + box.getMilkCount() + "个");
                box.notifyAll();
            }
        }
    }
}

// 消费者
class Customer implements  Runnable {
    private Box box;

    public Customer(Box box) {
        this.box = box;
    }

    @Override
    public void run() {
        while(true) {
           synchronized (box) {
               // 等于0不消费，生产
               if(box.getMilkCount() == 0) {
                   try {
                       box.wait();
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
               // 不等于0，消费
               box.setMilkCount(box.getMilkCount()-1);
               System.out.println(Thread.currentThread().getName() + "--消费1个剩余：-->" + box.getMilkCount() + "个");
               box.notifyAll();
           }
        }
    }
}

sleep()与wait()区别

sleep()是Thread类的静态方法，wait()是Object类的实例啊方法
sleep()不会释放锁，wait()会释放锁
sleep()可以用在任意位置，wait()只能用在同步代码块中

线程可见性

指令重排

待补充。。。

LockSupport工具类

线程阻塞的工具类，所有的方法都是静态方法，可以让线程再任意位置阻塞，阻塞之后也有唤醒方法。
park：停车。如果我们把Thread看成一辆车的化，park就是让车停下
uppark：就是让车启动然后跑起来

这里的park和unpark其实实现类wait和notify的功能
区别：
1.park不需要获取某个对象的锁(不能释放锁)
2.因为钟短park不会抛出Innerruptedxception，需要再park之后自行判断中断状态，然后做额外的处理

总结：
1.park和unpark可以实现wait和notify的功能，但是并不和wait和notify交叉使用
2.park和unpark不会出现死锁
3.

并发编程三大特性
1.原子性：原子操作可以实一个步骤，也可以是多个步骤，但是顺序不能乱，也不可以被切割只能执行其中的一部分，将整个操作视为一个整体。原子性不仅仅是多行代码，也可能是多条指令
2.可见性
3.有序性

synchronized lock：可以保证原子性、可见性、有序性

CAS： compare and swap，比较并交换，JDK11改成了compare and set
思路：就是给一个元素赋值的时候，先看看内存里的那个值到底变没变。
AQS: 抽象队列同步器，用来解决线程同步执行的问题

线程池

为什么要使用线程池

降低资源消耗,通过重复利用创建的线程降低创建和销毁线程造成的资源消耗
提高响应速度.当任务到达时,任务可以不需要等到线程创建就能立即执行
提高线程的可管理性.线程是比较稀缺的资源,如果无限制的创建,不仅会消耗系统资源,还会降低系统的稳定性,使用线程池可以进行统一的分配,调优和监控.

JDK自带的线程池

JDK自带的四种线程池通过Executors提供的

newCacheThreadPool: 创建一个可缓存的线程池,如果线程池长度超过处理需要,可以灵活回收空闲线程,若无可回收,创建新线程
newFixedThreadPool: 创建一个定场地线程池,可以控制线程最大并发数,超出的线程会在队列中等待
newScheduledThreadPool: 创建一个定长的线程池,支持定时及周期性任务执行
newSingleThreadExecutor: 创建一个单线程化的线程池,他只会用唯一的工作线程来执行任务,保证所有的任务按照指定顺序执行

激进的韭菜

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2022-08-02 第五小组顾祥全学习笔记 day26-JavaSE-多线程-基础部分

对于Java程序来说，使用java.exe命令时，会启动JVM，JVM就是一个进程，JVM会启动一个线程调用main方法，以及再启动一个垃圾回收线程负责看守。使用volatile关键字来保证一个变量在一次读写操作指令重排。不推荐使用JDK提供的stop()，destroy()方法(推荐让线程自己停下来，建议使用一个标志位进行终止变量。....................................
复制链接

扫一扫