JAVA多线程Thread

最新推荐文章于 2024-05-06 18:00:52 发布
最新推荐文章于 2024-05-06 18:00:52 发布
阅读量392 收藏 3
点赞数 6
分类专栏： java 文章标签： java 并发编程 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33498329/article/details/115106609
版权

jdk1.8中文api文档下载

目录

Lock

实现类
ReentrantLock();

构造方法
NonfairSync();非公平锁
FairSync();公平锁 可以先来后到
在这里插入图片描述

lock和synchronized的区别

synchronizedlock
java关键字java类
无法判断锁的状态可以判断是否获取到了锁
会自动释放锁lock锁需要手动释放（不释放会死锁）
线程获取到不到锁会一直等待lock.tryLock() 可以尝试获取锁，可设置超时时间
可重入锁，不可中断，非公平可重入锁，可以设置是否公平锁
适合锁少量代码同步问题适合锁大量同步代码块

synchronized和lock锁实现卖票问题

package com.yunwangl.juc.ticket;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.stream.Stream;

/**
 * @ClassName SellTicket
 * @Description
 * @Author LiuQunYu
 * @Date 2021/3/22 21:06
 * @Version V1.0
 **/
public class SellTicket {

    public static void main(String[] args) {

//        synchronizedSell(); // synchronized关键词实现
        LockSell(); // lock锁实现
    }


    public static void LockSell() {
        TicketLock ticket = new TicketLock();
        Stream.of("线程1", "线程2", "线程3", "线程4", "线程5").forEach(name -> {
            new Thread(() -> {
                while (ticket.num > 0) {
                    ticket.sell();
                }
            }, name).start();
        });
    }

    static class TicketLock {
        private Lock lock = new ReentrantLock();
        private int num = 1000;

        public void sell() {
            lock.lock();
            try {
                if (num > 0) {
                    System.out.println(Thread.currentThread().getName() + "卖出了第" + this.num-- + "张票");
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }

    }


    public static void synchronizedSell() {
        Ticket ticket = new Ticket();
        Stream.of("线程1", "线程2", "线程3", "线程4", "线程5").forEach(name -> {
            new Thread(() -> {
                while (ticket.num > 0) {
                    ticket.sell();
                }
            }, name).start();
        });
    }

    static class Ticket {
        private int num = 1000;

        public synchronized void sell() {
            if (num > 0) {
                System.out.println(Thread.currentThread().getName() + "卖出了第" + this.num-- + "张票");
            }
        }

    }
}

消费者生产者问题

线程等待避免使用if 应使用while循环判断
在这里插入图片描述

在这里插入图片描述
synchronized 线程等待
this.wait();
唤醒线程
this.notifyAll();

lock锁实现

final Condition condition = lock.newCondition();
condition.await();
condition.signalAll();

package com.yunwangl.juc.consumer;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.stream.Stream;

/**
 * @ClassName Demo
 * @Description
 * @Author LiuQunYu
 * @Date 2021/3/23 0:15
 * @Version V1.0
 **/
public class Demo {


    public static void main(String[] args) {
//        synchronizedDataPC();
//        lockDataPC();
        OrderPrintMethod();
    }

    /**
     * synchronized 实现消费者生产者问题
     */
    public static void synchronizedDataPC() {
        Data data = new Data();
        Stream.of("生产者线程1", "生产者线程2", "生产者线程3").forEach(name -> {
            new Thread(() -> {
                while (true) {
                    try {
                        data.increment();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, name).start();
        });

        Stream.of("消费者线程1", "消费者线程2", "消费者线程3").forEach(name -> {
            new Thread(() -> {
                while (true) {
                    try {
                        data.decrement();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, name).start();
        });
    }

    /**
     * synchronized 具体业务类
     */
    static class Data {
        private int num = 0;

        public synchronized void increment() throws InterruptedException {
            while (num != 0) {
                // 等待消费
                this.wait();
            }
            num++;
            System.out.println(Thread.currentThread().getName() + "生产数据->" + num);
            // 生产数据完成 通知消费者消费
            this.notifyAll();
        }

        public synchronized void decrement() throws InterruptedException {
            while (num == 0) {
                // 等待生产者生产
                this.wait();
            }
            // 消费数据
            num--;
            System.out.println(Thread.currentThread().getName() + "消费数据->" + num);
            // 通知生产者生产数据
            this.notifyAll();
        }
    }


    /**
     * lock锁实现简单消费者生产者问题
     */
    public static void lockDataPC() {
        LockData data = new LockData();
        Stream.of("生产者线程1", "生产者线程2", "生产者线程3").forEach(name -> {
            new Thread(() -> {
                while (true) {
                    data.increment();
                }
            }, name).start();
        });

        Stream.of("消费者线程1", "消费者线程2", "消费者线程3").forEach(name -> {
            new Thread(() -> {
                while (true) {
                    data.decrement();
                }
            }, name).start();
        });
    }


    /**
     * lock锁具体业务类
     */
    static class LockData {
        Lock lock = new ReentrantLock();
        final Condition condition = lock.newCondition();
        private int num = 0;

        public void increment() {
            lock.lock();
            try {
                while (num != 0) {
                    // 等待消费
                    condition.await();
                }
                // 生产数据
                num++;
                System.out.println(Thread.currentThread().getName() + "生产数据->" + num);
                // 生产数据完成 通知消费者消费
                condition.signalAll();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }

        public void decrement() {
            lock.lock();
            try {
                while (num == 0) {
                    // 等待生产者生产
                    condition.await();
                }
                // 消费数据
                num--;
                System.out.println(Thread.currentThread().getName() + "消费数据->" + num);
                // 通知生产者生产数据
                condition.signalAll();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }

        }
    }


    static void OrderPrintMethod() {
        OrderPrintData orderPrintData = new OrderPrintData();

        new Thread(() -> {
            while (true) {
                orderPrintData.print1();
            }
        }, "线程1").start();

        new Thread(() -> {
            while (true) {
                orderPrintData.print2();
            }
        }, "线程2").start();
        new Thread(() -> {
            while (true) {
                orderPrintData.print3();
            }
        }, "线程3").start();
    }


    /**
     * lock锁实现线程顺序打印依次执行
     */
    static class OrderPrintData {
        Lock lock = new ReentrantLock();
        final Condition condition1 = lock.newCondition();
        final Condition condition2 = lock.newCondition();
        final Condition condition3 = lock.newCondition();
        private int num = 1;

        public void print1() {
            lock.lock();
            try {
                while (num != 1) {
                    // 等待
                    condition1.await();
                }
                System.out.println(Thread.currentThread().getName() + "打印->" + num);
                num = 2;
                // 通知其他线程
                condition2.signal();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }

        public void print2() {
            lock.lock();
            try {
                while (num != 2) {
                    // 等待
                    condition2.await();
                }
                System.out.println(Thread.currentThread().getName() + "打印->" + num);
                num = 3;
                // 通知其他线程
                condition3.signal();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }

        public void print3() {
            lock.lock();
            try {
                while (num != 3) {
                    // 等待消费
                    condition3.await();
                }
                System.out.println(Thread.currentThread().getName() + "打印->" + num);
                num = 1;
                // 通知其他线程
                condition1.signal();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
}

锁问题 synchronized
没有被synchronized修饰的方法不受锁的影响

修饰类型锁的目标
修饰普通方法锁对象
修饰static方法锁类
修饰普通成员变量锁对象
修饰static成员变量锁类

集合并发修改问题

类名方法
ArrayList在这里插入图片描述
Vector在这里插入图片描述
Collections.synchronizedList()在这里插入图片描述
CopyOnWriteArrayList在这里插入图片描述
package com.yunwangl.juc.list;

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * @ClassName Demo
 * @Description 多线程并发集合修改问题
 * @Author LiuQunYu
 * @Date 2021/3/26 0:04
 * @Version V1.0
 **/
public class Demo {

    public static void main(String[] args) {
//        concurrenceList();
//        concurrenceVector();
//        concurrenceSyList();
        concurrenceCopyOnWriteList();
    }

    /**
     * list 并发操作测试
     *
     * 发生ConcurrentModificationException 并发修改异常
     */
    static void concurrenceList() {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                list.add(String.valueOf(UUID.randomUUID()));
                System.out.println(list);
            }).start();
        }

    }

    /**
     * 使用Vector集合解决并发修改异常问题 底层使用synchronized
     */
    static void concurrenceVector(){
        List<String> list = new Vector<>();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                list.add(String.valueOf(UUID.randomUUID()));
                System.out.println(list);
            }).start();
        }
    }

    /**
     * 使用集合工具Collections.synchronizedList 底层为内部类new SynchronizedList<>(list));
     * <p>
     *     public boolean add(E e) {
     *             synchronized (mutex) {return c.add(e);}
     *         }
     * </p>
     */
    static void concurrenceSyList(){
        List<String> list = Collections.synchronizedList(new ArrayList<String>());
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                list.add(String.valueOf(UUID.randomUUID()));
                System.out.println(list);
            }).start();
        }
    }

    /**
     * 底层实现 private transient volatile Object[] array;
     */
    static void concurrenceCopyOnWriteList(){
        List<String> list = new CopyOnWriteArrayList<String>();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                list.add(String.valueOf(UUID.randomUUID()));
                System.out.println(list);
            }).start();
        }
    }
}

线程池

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)

volatile关键词

肆意&
关注
  • 6
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
java 多线程Thread与runnable的区别
08-29
主要介绍了java 多线程Thread与runnable的区别的相关资料,java线程有两种方法继承thread类与实现runnable接口，下面就提供实例帮助大家理解，需要的朋友可以参考下
Java多线程之线程的创建与Thread类的使用
未见花闻的博客
03-29 2480
本篇文章介绍java多线程中Thread类的使用以及有关线程对象创建和常用方法。
Java多线程ThreadAPI详细介绍
08-25
主要介绍了Java多线程ThreadAPI详细介绍，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
java多线程Thread的实现方法代码详解
08-28
主要介绍了java多线程Thread的实现方法代码详解，涉及start()，run()，stop()，interrupt()，isInterrupted()，join()和join(long millis)等方法的介绍，具有一定借鉴价值，需要的朋友可以了解下。
JAVA多线程Thread和Runnable的实现
09-05
java中实现多线程有两种方法：一种是继承Thread类，另一种是实现Runnable接口。
java Thread 多线程
09-05
本篇文章小编为大家介绍，java Thread 多线程。需要的朋友参考下
链表刷题集
yajunjiao的专栏
04-30 904
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
《设计一款蓝牙热敏打印机》
唐顺才的博客
05-06 186
安卓apk用java + kotlin编写、上位机用Qt编写。主控芯片用易兆威蓝牙ic，通讯接口：蓝牙、串口、usb。
【一步一步了解Java系列】：探索Java基本类型与C语言的区别
2302_81249757的博客
04-29 1219
​​喜欢的一句话： 常常会回顾努力的自己，所以要为自己的努力留下足迹。作者：小闭。
Nacos 配置中心实例分析实践
m0_73557631的博客
05-03 1016
​ 浏览器: http://localhost:5000/nacos/config/ip。先创建e-commerce-nacos-config-client5000 模块。​ 启动e-commerce-nacos-config-client5000。​ 启动Nacos Server。
公考学习平台|基于SprinBoot+vue的公考学习平台(源码+数据库+文档)
weixin_66413741的博客
04-30 1362
本共享汽车管理系统有管理员和用户。管理员功能有个人中心，用户管理，投放地区管理，汽车信息管理，汽车投放管理，汽车入库管理，使用订单管理，汽车归还管理。用户可以在注册登录，可以对汽车进行使用产生订单，还可以归还。因而具有一定的实用性。本站是一个B/S模式系统，采用Spring Boot框架，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得共享汽车管理系统管理工作系统化、规范化。
SpringBoot实现图片上传（个人头像的修改）
m0_46590717的博客
04-29 1225
该文章适合对SpringBoot，Thymeleaf，layui入门的小伙伴。
【吃透Java手写】Spring(下)-AOP-事务及传播原理
bblb的博客
05-04 438
Spring(下)-AOP-事务及传播原理
Android 状态栏WiFi图标的显示逻辑
最新发布
xiaowang_lj的博客
05-06 213
定义相关函数，继承BroadcastReceiver监听系统广播，动态注册广播接收器。是状态栏WiFi图标更新的核心类。定义了 Wifi 信号更新所需的图标资源。
java return方法返回数组性
m0_73177400的博客
04-30 259
我们已经学过 返回的声明 和不返回的声明。如果我们需要返回多个数怎么办，那么这个时候就用数组了，我们知道数据类型int string long short .那么返回对象为数组时就相当于能把这些类型都包进去了。
数组模拟双链表-java
m0_63267251的博客
05-01 1116
当我们刷算法题时可以通过数组来模拟链表，比直接用结构体的代码会简洁一点。
C++深度解析教程笔记5
qq_35429166的博客
04-30 478
本文学习自狄泰软件学院 唐佐林老师的 C++深度解析教程，图片全部来源于课程PPT，仅用于个人学习记录。
MyBatis:mybatis基础操作
qq_55630615的博客
05-03 616
接口方法。
javaEE项目开发总结（前后端交互）
2301_77523019的博客
05-02 179
javaEE项目开发总结（前后端交互webServlet）
java多线程thread原理
04-04
Java中的多线程是通过Thread类实现的。每个线程都是一个独立的执行流，有自己的堆栈和程序计数器。 当一个Java程序启动时，一个主线程被创建并开始执行。主线程可以创建其他线程来执行其他任务。创建一个新线程可以...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值