多线程

已于 2023-05-23 16:23:20 修改
阅读量230 收藏
点赞数 1
分类专栏： 多线程 文章标签： java
于 2023-05-23 16:23:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49450828/article/details/130829820
版权

多线程

多线程实现方式

  1. 继承Thread

    public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            System.out.println(Thread.currentThread().getName() + " - - - " + i);
        }
    }
}

  2. 实现runnable

    public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            System.out.println(Thread.currentThread().getName() + " - - - " + i);
        }
    }
}

  3. 实现callable

    public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 1; i <= 10; i++) {
            System.out.println(Thread.currentThread().getName() + " - - - " + i);
        }
        return Thread.currentThread().getName() + " - - - 执行完毕!";
    }
}

  4. 设置和获取线程名称

    Thread t = new Thread();

t.setName('线程名称');
    
Thread.currentThread().getName();

  5. Thread中的方法

    // 休眠1秒
Thread.sleep(1000);

  6. 线程优先级

    Thread t = new Thread();

// min 5 -> max 10
t.setPricrity();

  7. 守护线程

    MyThread1 t1 = new MyThread1();

MyThread2 t2 = new MyThread2();

t1.setName("nvshen");
t2.setName("beitai");

// 设置t2为守护线程
// 当t1执行完毕，t2也没有继续运行的必要了
t2.setDaemon(true);

t1.start();
t2.start();

线程安全问题

  1. 卖票案例

    class MyRunable implements Runnable{
    private Integer tickets = 100;
    @Override
    public void run() {
        while (true){
            if (tickets <= 0){
                break;
            }else {
                tickets--;
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "：卖出第" + (tickets + 1) + "张票,剩余" + tickets + "张");
            }
        }
    }
}


    public static void main(String[] args) {
        MyRunable myRunable = new MyRunable();
        Thread t1 = new Thread(myRunable);
        t1.setName("【窗口 1】");
        Thread t2 = new Thread(myRunable);
        t2.setName("【窗口 2】");
        Thread t3 = new Thread(myRunable);
        t3.setName("【窗口 3】");
        t1.start();
        t2.start();
        t3.start();
}

     ......
【窗口 2】：在卖第11张票,剩余10张
【窗口 3】：在卖第8张票,剩余7张
【窗口 1】：在卖第8张票,剩余7张
【窗口 2】：在卖第8张票,剩余7张
【窗口 3】：在卖第5张票,剩余4张
【窗口 1】：在卖第5张票,剩余4张
【窗口 2】：在卖第5张票,剩余4张
【窗口 2】：在卖第2张票,剩余1张
【窗口 1】：在卖第2张票,剩余1张
【窗口 3】：在卖第2张票,剩余1张
【窗口 2】：在卖第1张票,剩余0张


【问题分析】：
	重复票：
	tickets = 100
	线程一执行tickets--后，tickets变为99，此时执行权被线程二抢走，线程二执行完tickets--后，tickets变为98，此时线程一中的tickets值也是98，就出现了重复卖票问题
	
	负号票：
	tickets = 1
    线程一执行tickets--之后，执行权被线程二抢走，此时tickets数量变为0，线程二又执行tickets--之后，此时tickets变为-1，执行权又被线程三抢走，此时就出现符负号票问题

  2. 同步代码块 | 同步方法

    synchronized(锁对象){
    
}

锁对象要唯一，多个线程要使用同一把锁

private synchronized void synchronizedMethod(){

}

  3. Lock锁

    private ReentrantLock lock = new ReentrantLock();

// 加锁
lock.lock();
    
// 解锁
lock.unlock();

  4. 死锁

    public class deadLock {
    public static void main(String[] args) {
        Object o1 = new Object();
        Object o2 = new Object();

        new Thread(()->{
            while (true){
                synchronized (o1){
                    synchronized (o2){
                        System.out.println("张三在吃饭");
                    }
                }
            }
        }).start();

        new Thread(()->{
            while (true){
                synchronized (o2){
                    synchronized (o1){
                        System.out.println("李四在洗脸");
                    }
                }
            }
        }).start();
    }
}

【第一个线程o1上锁后执行权被第二个线程抢走，o2上锁，此时线程一中拿不到o2锁，线程二中拿不到o1锁，产生死锁】

线程池

虚拟机中线程六种状态：
新建（NEW）创建线程对象
就绪（RUNNABLE）start方法
阻塞（BLOCKED）无法获得锁对象
等待（WAITING）wait方法
计时（TIMED_WAITING）sleep方法
结束（TERMINATED）全部代码运行完毕
// 创建默认线程池
public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();

        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName());
        });
    
        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName());
        });

        executorService.shutdown();
}

// 创建指定最多线程数的线程池
public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName());
        });
    
        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName());
        });

        executorService.shutdown();
}

public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName());
        });
    
        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName());
        });

    	// 获取线程池内线程数量
    	System.out.println(executorService.getPoolSize())
    	
        executorService.shutdown();
}

线程池对象-ThreadPoolExecutor

// 源码
public ThreadPoolExecutor(int corePoolSize,	
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), defaultHandler);
}
// corePoolSize							核心线程数
// maximumPoolSize						最大线程数	
// keepAliveTime						空闲线程存活时间
// unit									单位（TimeUnit.xx）
// workQueue							任务队列（阻塞队列）	new ArrayBlockingQueue(10)
// Executors.defaultThreadFactory()		线程工厂
// defaultHandler						任务拒绝策略		   new ThreadPoolExecutor().abortPolicy() 终止策略，超过的任务就不要了
参数解释示例
corePoolSize核心线程数5
maximumPoolSize最大线程数10
keepAliveTimeunit空闲线程存活时间10
unit单位TimeUnit.SECOND
workQueue任务队列（阻塞队列）new ArrayBlockingQueue(10)
Executors.defaultThreadFactory()线程工厂Executors.defaultThreadFactory()
defaultHandler任务拒绝策略new ThreadPoolExecutor().abortPolicy终止策略，超过的任务就不要了
任务拒绝策略
ThreadPoolExecutor().abortPolicy默认策略，丢弃任务并抛出RejectedExecutionException异常
ThreadPoolExecutor.DiscardPolicy丢弃任务，不抛出异常 不推荐的做法
ThreadPoolExecutor.DiscardOldestPolicy抛弃等待最久的任务，然后把当前任务加入队列
ThreadPoolExecutor.CallerRunsPolicy调用任务的run（）方法绕过线程池直接执行

volatile

// volatile修饰共享数据
public static volatile int money = 100000;

原子性

	所谓原子性是指在一次操作中，要么所有操作全部都得到执行且不会受任何因素的干扰而中断，要么所有操作都不执行，`多个操作是一个不可以分割的整体`

public class 原子性 {
    public static void main(String[] args) {
        MyAtomThread ma = new MyAtomThread();
        for (int i = 0; i < 100; i++) {
            new Thread(ma).start();
        }
    }
}

class MyAtomThread implements Runnable{
    private int count = 0;

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            count++;
            System.out.println("已经送了" + count + "个冰淇淋");
        }
    }
}

已经送了9988个冰淇淋
已经送了9989个冰淇淋
已经送了9990个冰淇淋
已经送了9991个冰淇淋
已经送了9992个冰淇淋
已经送了9993个冰淇淋
已经送了9994个冰淇淋
已经送了9995个冰淇淋
已经送了9996个冰淇淋
已经送了9997个冰淇淋
已经送了9998个冰淇淋
已经送了9999个冰淇淋


// volatile不能保证原子性

// 同步代码块方式

// jdk1.5 出现atomic原子包
// AtomicInteger

public class 原子性 {
    public static void main(String[] args) {
        MyAtomThread ma = new MyAtomThread();
        for (int i = 0; i < 100; i++) {
            new Thread(ma).start();
        }
    }
}

class MyAtomThread implements Runnable{
    AtomicInteger count = new AtomicInteger(0);

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("已经送了" + count.addAndGet(1) + "个冰淇淋");
        }
    }
}
AtomicInteger中的方法解释
int get()获取值
int getAndIncrement()自增1，返回自增前的值
int IncrementAndGet()自增1，返回自增后的值
int addAndGet(x)增加x,返回增加后的值
int getAndSet(x)设置为x，返回旧值

AtomicInteger原理： 自旋锁 + CAS算法

# CAS算法：有3个操作数（内存值V，旧的预期值A，要修改的值B）
	当旧的预期值A == 内存值，此时修改成功，将V改为B
	当旧的预期值A ! = 内存值，此时修改失败，不做任何操作
	并从新获取现在的最新值（这个重新获取的动作就是自旋）

synchronized和CAS区别

# 相同点：
 	synchronized每次操作共享数据都会上锁。（悲观锁）

# 不同点：
	CAS从乐观角度出发，假设每次获取数据别人都不会修改，所以不会上锁，只不过在修改共享数据的时候，会检查一下，别人有没有修改过这个数据。如果别人修改过，那么就再次获取现在最新的值，如果别人没有修改过，那么直接修改共享数据的值。（乐观锁）

并发工具类

1. HashMap 是线程不安全的，多线程环境下会有数据安全问题；
2. Hashtable 是线程安全的，但是会将整张表锁起来，效率低下；
3. ConcurrentHashMap 也是线程安全的，效率较高。

jdk1.7前ConcurrentHashMap原理解析:
创建对象:
	  创建一个默认长度为16，默认加载因子为0.75的数组，数组名为Segment
	  再创建一个长度为2的小数组，把地址值赋值给0索引，其他索引都是null
添加：
	  第一次会根据键的哈希值来计算出在大数组中应存入的位置，如果为null，则按照模板创建小数组，创建完毕，会二次哈希，计算出在小数组中应存入的位置，为null直接存入，如果不为null，就会根据记录的地址值找到小数组，二次哈希，计算出在小数组中应存入的位置，如果需要扩容，则将小数组扩容两倍，如果不需要扩容，则就会看小数组的这个位置有没有元素，如果没有元素，则直接存，如果有元素，旧会调用equals方法，比较属性值，如果equals为true，则不存，如果是false，形成哈希桶结构。

jdk1.8后ConcurrentHashMap原理解析:
	底层结构：哈希表（数组、链表、红黑树的结合体）
	结合CAS机制 + synchronized同步代码块形式保证线程安全
	
	如果使用空参构造创建ConcurrentHashMap对象，则什么事情都不做，在第一次添加元素的时候创建哈希表；
	计算当前元素应存入的索引；
	如果该索引位置为null，则利用cas算法，将本届点添加到数组中；
	如果该索引位置不为null，则利用volayile关键字获得当前位置最新的结点地址，挂在他下面，变成链表；
	当链表的长度大于等于8，自动转换成红黑树；
	以链表或者红黑树头结点为锁对象，配合悲观锁保证多线程操作集合时数据的安全性。

CountDownLatch

public class CountDownLatch_demo {
    public static void main(String[] args) {
        CountDownLatch countDownLatch = new CountDownLatch(3);
        new Thread(new Mother(countDownLatch)).start();
        new Thread(new Son1(countDownLatch)).start();
        new Thread(new Son2(countDownLatch)).start();
        new Thread(new Son3(countDownLatch)).start();
    }
}


class Mother implements Runnable{
    private CountDownLatch countDownLatch;
    public Mother(CountDownLatch countDownLatch){
        this.countDownLatch = countDownLatch;
    }
    
    @Override
    public void run() {
        try {
            // 妈妈线程在等待
            countDownLatch.await();
            System.out.println("妈妈收拾碗筷!");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class Son1 implements Runnable{
    private CountDownLatch countDownLatch;
    public Son1(CountDownLatch countDownLatch){
        this.countDownLatch = countDownLatch;
    }
    
    @Override
    public void run() {
        System.out.println("son1吃完了");
        countDownLatch.countDown();
    }
}

class Son2 implements Runnable{
    private CountDownLatch countDownLatch;
    public Son2(CountDownLatch countDownLatch){
        this.countDownLatch = countDownLatch;
    }
    
    @Override
    public void run() {
        System.out.println("son2吃完了");
        countDownLatch.countDown();
    }
}

class Son3 implements Runnable{
    private CountDownLatch countDownLatch;
    public Son3(CountDownLatch countDownLatch){
        this.countDownLatch = countDownLatch;
    }
    
    @Override
    public void run() {
        System.out.println("son3吃完了");
        countDownLatch.countDown();
    }
}


# 使用场景
让某一条线程等待其他线程执行完毕之后再执行。
方法解释
public CountDownLatch(int count)参数传递线程数，表示等待线程数量，并等以一个计数器
public void await()让线程等待，计数器为0，唤醒等待线程
public void countDown()当前线程执行完毕，计数器-1

Semaphore

public class Semaphore_demo {
    public static void main(String[] args) {
        MyRunnable_Semaphore myRunnable_semaphore = new MyRunnable_Semaphore();
        for (int i = 0; i < 10; i++) {
            new Thread(myRunnable_semaphore).start();
        }
    }
}

class MyRunnable_Semaphore implements Runnable{
    Semaphore semaphore = new Semaphore(2);

    @Override
    public void run() {
        try {
            semaphore.acquire();
            System.out.println(Thread.currentThread().getName() + "获得通行证");
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + "归还通行证");
            semaphore.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Thread-2获得通行证
Thread-6获得通行证
Thread-2归还通行证
Thread-6归还通行证
Thread-4获得通行证
Thread-9获得通行证
Thread-4归还通行证
Thread-9归还通行证
Thread-5获得通行证
Thread-8获得通行证
Thread-8归还通行证
Thread-5归还通行证
Thread-1获得通行证
Thread-7获得通行证
Thread-1归还通行证
Thread-7归还通行证
Thread-3获得通行证
Thread-0获得通行证
Thread-3归还通行证
Thread-0归还通行证
obud
关注
专栏目录
micropython多线程_Python 多线程
weixin_33379878的博客
02-07 2355
Python 多线程多线程类似于同时执行多个不同程序，多线程运行有如下优点：使用线程可以把占据长时间的程序中的任务放到后台去处理。用户界面可以更加吸引人，这样比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理的进度程序的运行速度可能加快在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。在这种情况下我们可以释放一些珍贵的资源如内存占用等等。线程在执行...
python多线程
qq_38889350的博客
07-13 3307
python多线程
深入理解多线程概念、同步与无锁机制
热门推荐
张彦峰的博客
10-14 4万+
介绍多线程编程的相关概念、同步机制以及无锁编程。从线程的基础概念出发，包括逻辑线程和硬件线程的比较，以及线程、核心和函数的关系。随后，我们探讨了多线程编程的基本原则，包括时间分片、上下文切换、线程安全函数和可重入函数等。接着，我们讨论了为什么需要多线程同步、什么情况需要进行同步以及多线程同步的方式，包括串行化、原子操作和锁等。我们还深入研究了非阻塞的无锁同步机制，如CAS循环和无锁数据结构。最后，我们解释了程序序、内存序、乱序执行、存储缓冲区和失效队列等概念，以帮助更好地理解多线程编程。
socket多线程
weixin_53331739的博客
08-10 2484
socket多线程
Java多线程详解
。。。
07-29 5278
今天我们聊一聊多线程，谈到多线程，很多人就开始难受，这是一个一听就头疼的话题，但是，我希望你在看完这篇文章后能对多线程有一个深入的了解。 案例 那么，首先我就举一个电影院卖票的例子来模拟多线程。 复仇者联盟4上映的那段时间电影院那可是门庭若市啊，那么我们假设现在有一个电影院正在上映复仇者联盟4，共有100张票，而它有三个售票窗口，我们来模拟一下这个电影院的售票情况。 首先创建SellTicket类...
多线程常见面试题
Lucky_mzc的博客
08-23 3097
死锁多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。互斥条件：该资源任意一个时刻只由一个线程占用。请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。不剥夺条件:线程已获得的资源在末使用完之前不能被其他线程强行剥夺，只有自己使用完毕后才释放资源。循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。如何避免死锁？只要破坏产生死锁的四个条件中的其中一个就可以了。
python多进程与多线程
内心不种满鲜花就会长满杂草
08-03 3281
进程程(Process)是资源分配的最小单位，它是操作系统进行资源分配和调度运行的基本单位，通俗理解：一个正在运行的程序就是一个进程。例如：正在运行的qq，微信等他们都是一个进程
多线程的优缺点
小小小虾米儿~的博客
06-17 4390
最近手上拿到一个程序，其中是一个视频监控的小程序，其中调用了线程，但是调试的时候出现的BUG，调试了N久，无果。最后，我把线程函数用一个普通的函数替代了，就没有错误了，后来，变思索，此处为何要用线程，不用不行吗？调用线程的有何优点？何时适用？摘自： http:...
C++ Qt开发：运用QThread多线程组件
CSDN
03-06 3712
Qt 是一个跨平台C++图形界面开发库，利用Qt可以快速开发跨平台窗体应用程序，在Qt中我们可以通过拖拽的方式将不同组件放到指定的位置，实现图形化开发极大的方便了开发效率，本章将重点介绍如何运用`QThread`组件实现多线程功能。
Java - 多线程
了解➔熟悉➔掌握➔精通
03-23 3万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net 引 如果对什么是线程、什么是进程仍存有疑惑，请先Google之，因为这两个概念不在本文讨论的范围之内。 用多线程只有一个目的，那就是更好的利用CPU的资源，因为所有的多线程代码都可以用单线程来实现。说这个话其实只有一半对，因为反应”多角色”的程序...
QT中利用TCP协议实现了一个多线程的文件互传系统
06-09
在QT框架下，利用TCP协议实现一个多线程的文件互传系统是一项常见的任务，它涉及到网络编程、多线程处理以及文件操作等多个方面。本文将深入探讨这些关键知识点。 首先，TCP（Transmission Control Protocol）是一...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
Android多线程文件夹下载及断点续传
08-07
在Android开发中，进行大文件下载时，为了提高效率并充分利用设备资源，通常会采用多线程下载技术。此外，为了提升用户体验，断点续传功能也显得尤为重要，尤其是在网络不稳定或者用户中断下载后，可以从上次停止的...
Qt 多线程及简单实例 demo
03-07
Qt 多线程及简单实例 demo。 多线程的几大特点： 1.多线程的执行顺序无法保证，与操作系统的调度策略和线程优先级等因素有关。 2.多线程的切换可能发生在任何时刻、任何地点。 3.多线程对代码的敏感度高，因此对...
Java-网络
最新发布
2301_81543552的博客
09-14 468
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
上传文件到钉盘流程详解
jspyth的博客
09-14 502
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
Java集合：Stack详解
yang_brother的博客
09-10 609
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
C++位图的实现与详解
2301_80468112的博客
09-09 667
在讲解位图之前我们先来看一道很经典的面试题。给40亿个不重复的无符号整数，没排过序。给一个无符号整数，如何快速判断一个数是否在这40亿个数中。我们有以下两种种解决方法：1. 遍历，时间复杂度O(N)。（太慢）2. 排序(O(NlogN))，利用二分查找: logN。深入分析:解题思路2是否可行，我们先算算40亿个数据大概需要多少内存。
Java wrapperr打包springboot项目到linux和Windows
欢迎查阅
09-14 831
测试启动就是点击App.bat 就会有信息的输出 installApp就是注册为一个windows上的一个服务。上图文件复制的地方 全部复制过去 保留自己需要的 然后去掉后缀.in。下载：linux的目前免费的 windows 64位的好像收费的。前提： 一定要有Java环境（我使用的是jdk1.8）解压的目录，然后我们新建自己的项目目录java-jsw。前面是你解压的原文件 后边是你自己建的目录路径。步骤和上面的一样 不过复制的文件不一样。下载一个社区版本的应该就够用了。需要注意的点 有Java环境。
Linux多线程编程详解：pthread实践与指南
Linux多线程编程指南是一份由Sun Microsystems提供的文档，专注于在Linux环境下使用POSIX线程库（pthread）进行并发编程。这份文档涵盖了多线程编程的基础概念、设计原则以及在Solaris操作系统中的应用。 1. **概述...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

obud

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值