Java 多线程学习笔记

最新推荐文章于 2024-07-10 21:37:49 发布

程序员小章

最新推荐文章于 2024-07-10 21:37:49 发布

阅读量839

点赞数 2

分类专栏： Java笔记文章标签：多线程 java jvm 并发编程编程语言

原文链接：https://blog.csdn.net/HNU_Csee_wjw/article/details/108082426

版权

Java笔记专栏收录该内容

103 篇文章 20 订阅

订阅专栏

Java 高级篇

笔记首页

序号	内容	链接地址
1	IO流	https://blog.csdn.net/weixin_44141495/article/details/108165699
2	多线程	https://blog.csdn.net/weixin_44141495/article/details/108277941
3	网络编程	https://blog.csdn.net/weixin_44141495/article/details/108190461
4	Json	https://blog.csdn.net/weixin_44141495/article/details/108285762
5	Xml	https://blog.csdn.net/weixin_44141495/article/details/108285125
6	反射	https://blog.csdn.net/weixin_44141495/article/details/108291945
7	注解	https://blog.csdn.net/weixin_44141495/article/details/108293331
8	枚举	https://blog.csdn.net/weixin_44141495/article/details/108696056
9	Java8新特性	https://blog.csdn.net/weixin_44141495/article/details/108696123

Java多线程笔记（搬运）

文章目录

Java 高级篇
Java多线程笔记（搬运）

1 多线程概述

1.1 线程与进程

进程：

是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间

线程：

是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少有一个线程
线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程

1.2 线程调度

分时调度

所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

抢占式调度

优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。
CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

1.3 同步&异步

同步：排队执行 , 效率低但是安全。

异步：同时执行 , 效率高但是数据不安全。

1.4 并发&并行

并发：指两个或多个事件在同一个时间段内发生。

并行：指两个或多个事件在同一时刻发生（同时发生）。

2 多线程的实现

2.1 继承Thread

2.1.1 Thread类

构造方法：

Thread() 
Thread(String name)
Thread(Runnable target) 
Thread(Runnable target, String name)

其中name是线程的名称

常用方法：

long getId()

返回此Thread的标识符。

String getName()

返回此线程的名称。

void start()

导致此线程开始执行; Java虚拟机调用此线程的run方法。

void stop() 已过时。

这种方法本质上是不安全的。现在应该是通知线程该结束了，然后让线程自杀。比如定义一个flag执行时不断观察这个flag，如果flag变成false了就从run方法中return

static void sleep(long millis)

导致当前正在执行的线程休眠（暂时停止执行）指定的毫秒数，具体取决于系统计时器和调度程序的精度和准确性。

static void sleep(long millis, int nanos)

导致当前正在执行的线程休眠（暂时停止执行）指定的毫秒数加上指定的纳秒数，具体取决于系统定时器和调度程序的精度和准确性。

void setDaemon(boolean on)

将此线程标记为 daemon（守护）线程或用户线程。用户线程是自己决定自己的死亡，守护线程是当所有用户线程死亡后自动死亡。

字段：

static int MAX_PRIORITY

线程可以拥有的最大优先级。

static int MIN_PRIORITY

线程可以拥有的最低优先级。

static int NORM_PRIORITY

分配给线程的默认优先级。

2.1.2 具体实现

public class MyThread extends Thread {
    //run方法就是线程要执行的任务方法
    @Override
    public void run() {
        //这里的代码就是一条新的执行路径
        //这个执行路径是触发方式，不是调用run方法，而是通过thread对象的start方法来启动任务
        for (int i = 0; i < 10; i++) {
            System.out.println("锄禾日当午" + i);
        }
    }
}
public class Demo1 {
    public static void main(String[] args) {

        MyThread m = new MyThread();
        m.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("汗滴禾下土"+i);
        }
}

每个线程都拥有自己的栈空间，线程中的方法就在自己的栈空间内，共用一份堆内存。

匿名内部类的实现方式：

new Thread(){
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("12345"+i);
        }
    }
}.start();

2.2 实现Runnable接口

实现接口的这个类可以看成是一个任务类：

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        //线程的任务
        for (int i = 0; i < 10; i++) {
            System.out.println("锄禾日当午"+i);
        }
    }
}
public class Demo1 {
    public static void main(String[] args) {
        //实现runnable
        //1 创建一个任务对象
        MyRunnable r = new MyRunnable();
        //创建一个线程并给他一个任务
        Thread t = new Thread(r);
        //启动线程
        t.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("汗滴禾下土"+i);
        }
    }
}

实现Runnable与继承Thread相比有如下优势：

1.通过创建任务，然后给线程分配任务的方式实现多线程，更适合多个线程同时执行任务的情况

2，可以避免单继承所带来的局限性

3，任务与线程是分离的，提高了程序的健壮性

4，后期学习的线程池技术，接受Runnable类型的任务，不接受Thread类型的线程

3 线程操作

3.1 设置和获取线程名称

Thread.currentThread().getName()
public class Demo3 {
    public static void main(String[] args) {
        //如何获取线程的名称
        System.out.println(Thread.currentThread().getName());
        //两种设置线程名称的方式
        Thread t = new Thread(new MyRunnable());
        t.setName("wwww");
        t.start();
        new Thread(new MyRunnable(),"锄禾日当午").start();
        //不设置的有默认的名字
        new Thread(new MyRunnable()).start();
    }
    
    static class MyRunnable implements Runnable{
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName());
        }
    }
}

执行结果：

3.2 线程休眠

public static void main(String[] args) throws InterruptedException {
    //线程的休眠
    for (int i = 0; i < 10; i++) {
        System.out.println(i);
        Thread.sleep(1000);     //1000毫秒
    }
}

3.3 线程阻塞

一般比较耗时的操作都可以看成线程阻塞，比如文件的读取、接收用户输入

也被称为耗时操作。

3.4 线程的中断

一个线程是一个独立的执行路径，它是否结束应该由其自身决定。

可以给线程打上标记，中断时会有一个异常，程序员可以在catch块中处理决定是否让其死亡。

例：主线程执行完毕后给t1线程添加一个中断标记

public class Demo5 {
    public static void main(String[] args) {
        //线程中断
        //一个线程是一个独立的执行路径，它是否结束应该由其自身决定
        Thread t1 = new Thread(new MyRunnable());
        t1.start();
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //给线程t1添加中断标记
        t1.interrupt();
    }

    static class MyRunnable implements Runnable{

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName()+":"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    //e.printStackTrace();
                    System.out.println("发现了中断标记，线程自杀");
                    return;
                }
            }
        }
    }
}

在sleep时会检查是否有InterruptedException

3.5 守护线程

线程分为守护线程和用户线程

用户线程：当一个进程不包含任何的存活的用户线程时，进行结束。
守护线程:守护用户线程的，当最后一个用户线程结束时，所有守护线程自动死亡。

public class Demo6 {
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyRunnable());
        //设置守护线程（主线程死亡时t1就死亡）
        t1.setDaemon(true);
        t1.start();
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    static class MyRunnable implements Runnable{

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName()+":"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

4 线程安全

4.1 不安全例子

多个线程争抢同一个变量

买票程序：

public class Demo7 {
    public static void main(String[] args) {
        //线程不安全
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable{
        //总票数
        private int count = 5;
        @Override
        public void run() {
            while (count>0){
                //卖票
                System.out.println("正在准备卖票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println("卖票结束,余票："+count);
            }
        }
    }
}

4.2 线程安全——同步代码块

格式：

synchronized（锁对象）{

}

java中任何对象都可以作为锁对象。

注意所有线程一定要看同一把锁。

public class Demo8 {
    public static void main(String[] args) {
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable{
        //总票数
        private int count = 10;
        private Object o = new Object();
        @Override
        public void run() {
            //Object o = new Object();    //这里不是同一把锁，所以锁不住
                while (true) {
                    synchronized (o) {
                        if (count > 0) {
                         //卖票
                            System.out.println("正在准备卖票");
                            try {
                            Thread.sleep(1000);
                            } catch (InterruptedException e) {
                            e.printStackTrace();
                            }
                            count--;
                            System.out.println(Thread.currentThread().getName()+"卖票结束,余票：" + count);
                        }else {
                            break;
                        }

                }
            }
        }
    }
}

4.3 线程安全——同步方法

以方法为单位进行加锁。但必须是对同一个任务runnable进行加锁才有效果。

public class Demo9 {
    public static void main(String[] args) {
        //线程不安全
        //解决方案2  同步方法
        Runnable runnable = new Ticket();
        new Thread(runnable).start();
        new Thread(runnable).start();
        new Thread(runnable).start();
    }

    static class Ticket implements Runnable{
        //总票数
        private int count = 10;
        @Override
        public void run() {
            while (true) {
                boolean flag = sale();
                if(!flag){
                    break;
                }
            }
        }
        
        public synchronized boolean sale(){
            if (count > 0) {
                //卖票
                System.out.println("正在准备卖票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println(Thread.currentThread().getName()+"卖票结束,余票：" + count);
                return true;
            }
                return false;
        }
    }
}

4.4 线程安全——显式锁Lock

同步代码块和同步方法都属于隐式锁。

显式锁 Lock 子类 ReentrantLock

public class Demo10 {
    public static void main(String[] args) {
        //线程不安全
        //解决方案1   显示锁  Lock  子类 ReentrantLock

        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable{
        //总票数
        private int count = 10;
        private Lock l = new ReentrantLock();
        @Override
        public void run() {
            while (true) {
                l.lock();
                    if (count > 0) {
                        //卖票
                        System.out.println("正在准备卖票");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        count--;
                        System.out.println(Thread.currentThread().getName()+"卖票结束,余票：" + count);
                    }else {
                        break;
                    }
                l.unlock();
            }
        }
    }
}

4.5 公平锁与不公平锁

公平锁：先来等待的先执行

不公平锁：解锁后大家一起抢

创建公平锁：

Lock l = new ReentrantLock(true);

4.6 线程死锁

简单来说就是A等B，B等A

public class Demo11 {
    public static void main(String[] args) {
        //线程死锁
        Culprit c = new Culprit();
        Police p = new Police();
        new MyThread(c,p).start();
        c.say(p);
    }

    static class MyThread extends Thread{
        private Culprit c;
        private Police p;
        MyThread(Culprit c,Police p){
            this.c = c;
            this.p = p;
        }

        @Override
        public void run() {
            p.say(c);
        }
    }
    static class Culprit{
        public synchronized void say(Police p){
            System.out.println("罪犯：你放了我，我放了人质");
            p.fun();
        }
        public synchronized void fun(){
            System.out.println("罪犯被放了，罪犯也放了人质");
        }
    }
    static class Police{
        public synchronized void say(Culprit c){
            System.out.println("警察：你放了人质，我放了你");
            c.fun();
        }
        public synchronized void fun(){
            System.out.println("警察救了人质，但是罪犯跑了");
        }
    }
}

解决方法：在任何有可能导致锁产生的方法里，不要再调用另一个方法让锁产生。

5 多线程通信

Object类中存在以下方法：

void notify()

唤醒正在此对象监视器上等待的单个线程。

void notifyAll()

唤醒等待此对象监视器的所有线程。

void wait()

导致当前线程等待它被唤醒，通常是通知或中断。

void wait(long timeoutMillis)

导致当前线程等待它被唤醒，通常是通知或中断，或者直到经过一定的时间。

void wait(long timeoutMillis, int nanos)

导致当前线程等待它被唤醒，通常是通知或中断，或者直到经过一定的时间。

必须用同一个对象来中断或唤醒某个线程。

5.1 生产者消费者问题

A生产数据，B要用A生产的数据使用。

设计厨师类和服务员类都实现多线程和一个食物类，一个生产食物，另一个消费食物。

厨师做完菜之后叫醒服务员端菜，然后厨师睡着；服务员端完菜之后叫醒厨师做菜然后睡着。

public class Demo12 {
    public static void main(String[] args) {
        //多线程通信    生产者与消费者问题
        Food f = new Food();
        new Cook(f).start();
        new Waiter(f).start();
    }

    /**
     * 厨师类，调用set
     */
    static class Cook extends Thread{
        private Food f;

        public Cook(Food f) {
            this.f = f;
        }

        @Override
        public void run() {
            for (int i = 0; i < 100; i++) { // 循环生产100份菜
                if(i%2==0){
                    f.setNameAndTaste("小米粥","甜味");
                }else {
                    f.setNameAndTaste("煎饼果子","甜辣味");
                }
            }
        }

    }

    /**
     * 服务员类，调用get
     */
    static class Waiter extends Thread{
        private Food f;

        public Waiter(Food f) {
            this.f = f;
        }

        @Override
        public void run() { // 循环取出100份菜
            for (int i = 0; i < 100; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                f.get();
            }
        }

    }

    /**
     * 食物类
     */
    static class Food{
        private String name;
        private String taste;
        //true表示可以做菜
        boolean flag = true;

        /**
         * 生产方法
         * @param name
         * @param taste
         */
        public synchronized void setNameAndTaste(String name,String taste){
            if(flag){
                this.name = name;
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.taste = taste;
                flag = false;   // 做完菜之后不能再做菜了

                this.notifyAll();   // 叫醒服务员
                try {
                    this.wait();    // 自己睡过去
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        /**
         * 消费方法
         */
        public synchronized void get(){
            if(!flag){
                System.out.println("服务员端走的菜的名称是："+name+",味道是："+taste);
                flag = true;    // 让厨师开始做菜

                this.notifyAll();   // 把厨师唤醒
                try {
                    this.wait();    // 自己睡过去
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

6 线程的六种状态

线程可以处于以下状态之一：

尚未启动的线程处于此状态。

RUNNABLE

在Java虚拟机中执行的线程处于此状态。

BLOCKED

被阻塞等待监视器锁定的线程处于此状态。

WAITING

无限期等待另一个线程执行特定操作的线程处于此状态。

TIMED_WAITING

正在等待另一个线程执行最多指定等待时间的操作的线程处于此状态。

TERMINATED

已退出的线程处于此状态。

7 带返回值的线程Callable

7.1 Runnable 与 Callable

接口定义：

//Callable接口
public interface Callable<V> {
    V call() throws Exception;
}

//Runnable接口
public interface Runnable {
    public abstract void run();
}

7.2 Callable使用步骤

\1. 编写类实现Callable接口 , 实现call方法

class XXX implements Callable<T> {
    @Override
    public <T> call() throws Exception {
        return T;
    }
}

\2. 创建FutureTask对象 , 并传入第一步编写的Callable类对象

FutureTask<Integer> future = new FutureTask<>(callable);

\3. 通过Thread,启动线程

new Thread(future).start();

7.3 Runnable 与 Callable的相同点

都是接口
都可以编写多线程程序
都采用Thread.start()启动线程

7.4 Runnable 与 Callable的不同点

Runnable没有返回值；Callable可以返回执行结果
Callable接口的call()允许抛出异常；Runnable的run()不能抛出

7.5 Callable获取返回值

Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。

8 线程池 Executors

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。

8.1 线程池的好处

降低资源消耗。
提高响应速度。
提高线程的可管理性。

8.2 Java中的四种线程池 ExecutorService

8.2.1 缓存线程池

public static void main(String[] args) {
   
    /**
    * 缓存线程池.
    * (长度无限制)
    * 执行流程:
    *     1. 判断线程池是否存在空闲线程
    *     2. 存在则使用
    *     3. 不存在,则创建线程 并放入线程池, 然后使用
    */
    ExecutorService service = Executors.newCachedThreadPool();
    // 向线程池中 加入 新的任务
    service.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"锄禾日当午");
        }
    });
    
    service.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"锄禾日当午");
        }
    });
    
    service.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"锄禾日当午");
        }
    });

    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

8.2.2 定长线程池

public static void main(String[] args) {
    ExecutorService service = Executors.newFixedThreadPool(2);
    service.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    });
    service.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    });
    service.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"锄禾日当午");
        }
    });
}

线程池长度只有2，所以第三行要在sleep了3秒以后才会执行。

8.2.3 单线程线程池

public class Demo15 {
    /*单线程线程池
    执行流程
        1 判断线程池的那个线程是否空闲
        2 空闲则使用
        3 不空闲则等待它空闲后再使用
    **/
    public static void main(String[] args) {
        ExecutorService service = Executors.newSingleThreadExecutor();
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jnI28cbX-1598593740238)(C:\Users\Faker\Desktop\123.assets\clipboard (5)].png)

8.2.4 周期性任务定长线程池

定时执行一次：

//参数1：定时执行的任务
//参数2：时长数字
//参数3：2的时间单位    Timeunit的常量指定
scheduledExecutorService.schedule(new Runnable() {
     @Override
     public void run() {
         System.out.println(Thread.currentThread().getName()+"锄禾日当午");
     }
 },5, TimeUnit.SECONDS);      //5秒钟后执行*/

周期性执行：

/*
周期性执行任务
    参数1：任务
    参数2：延迟时长数字（第一次在执行上面时间以后）
    参数3：周期时长数字（没隔多久执行一次）
    参数4：时长数字的单位
* **/
scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"锄禾日当午");
    }
},5,1,TimeUnit.SECONDS);

程序员小章

关注

2
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
Java 多线程学习笔记

文章目录1.1 线程与进程进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间线程：是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少有一个线程线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程1.2 线程调度分时调度所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。抢占式调度优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选
复制链接

扫一扫