多线程和并发

于 2024-02-24 17:02:15 发布
阅读量867 收藏 18
点赞数 24
文章标签： 多线程 并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44518089/article/details/136263875
版权
本文详细介绍了Java中的线程概念、进程与线程的关系，包括线程的创建方式（Thread、Runnable和Callable），并发问题、线程状态、线程同步（synchronized和lock）、死锁预防、以及线程池的使用。
摘要由CSDN通过智能技术生成

线程

进程：在操作系统中运行的程序，一个进程可以包含多个线程
程序就是指令和数据的有序集合，静态概念
进程就是执行程序的一次执行过程，动态概念系统资源分配的单元

一个进程中包含多个线程，一个进程至少包含一个线程
线程时cpu调度和执行的单位
线程是独立的执行路径
程序运行时，即使没有自己创建线程。后台也会有多个线程，如主线程，gcxianc
main()是主线程，为系统的入口，用于执行整个程序
在一个进程中如果开辟了多个线程，线程的运行由调度器进行安排调度，调度器与操作系统密切相关，先后顺序不能干预
对同一份资源操作时，会存在资源抢夺的问题，加入并发控制
线程会带来额外的开销
每个线程对自己的工作内存交互，内存控制不当会造成数据不一致

线程创建Thread、Runnable、Callable

继承Thread

1.自定义线程类继承Thread类
重新run()方法，编写线程执行体
创建线程对象，调用start方法();

使用Thread实现网图下载：

package com.ty.threadAndRunableAndCallable;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

public class ThreadDownLoader extends Thread {
    private String url;//网图地址
    private String fileName;//
    public ThreadDownLoader(String url,String fileName){
        this.url = url;
        this.fileName = fileName;
    }

    @Override
    public void run(){
        WebDownLoader webDownLoader = new WebDownLoader();
        webDownLoader.downLoader(url,fileName);
        System.out.println("文件名："+ fileName);
    }

    public static void main(String[] args) {
        ThreadDownLoader t1 = new ThreadDownLoader("https://pic.rmb.bdstatic.com/bjh/914b8c0f9814b14c5fedeec7ec6615df5813.jpeg", "1.jpeg");
        ThreadDownLoader t2 = new ThreadDownLoader("https://n.sinaimg.cn/sinakd2020723s/213/w2048h1365/20200723/3918-iwtqvyk4060964.jpg", "2.jpg");
        ThreadDownLoader t3 = new ThreadDownLoader("https://file.ccmapp.cn/group1/M00/16/64/rApntl7CSdeAbpYqABArOjGaasg001.jpg", "3.jpg");

        t1.start();
        t2.start();
        t3.start();
    }
}

class WebDownLoader{
    public void downLoader(String url,String fileName){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(fileName));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO exception！！！ downLoader Error！！！");
        }
    }
}

实现Runnable

定义MyRunnable类实现Runnable接口
实现run()方法，编写线程体
创建线程对象，调用start()方法启动线程

Thread和Runnable区别

Thread不建议使用，避免OOP单继承局限，
Runnable具有多线程能力
启动线程：传入目标对象+Thread对象.start()
推荐是哦哟牛皋，避免单继承的局限性，灵活方便，方便同一个对象被多个线程使用

多线程模拟出票：并发问题

package com.ty.threadAndRunableAndCallable;

public class ConcurrencyQuestion implements Runnable {

    private int tickerNums = 10;

    @Override
    public void run() {
        while (true){
            if (tickerNums <= 0){
                break;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"拿到了，第"+(tickerNums--)+"票");
        }
    }

    public static void main(String[] args) {
        ConcurrencyQuestion concurrencyQuestionTicker = new ConcurrencyQuestion();
        new Thread(concurrencyQuestionTicker,"aa").start();
        new Thread(concurrencyQuestionTicker,"bb").start();
        new Thread(concurrencyQuestionTicker,"cc").start();
    }

}

多线程模拟龟兔赛跑

在这里插入图片描述

package com.ty.threadAndRunableAndCallable;

public class ConcurrencyRace implements Runnable{
    private String winner;
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {

            //模拟兔子休息
            if (Thread.currentThread().getName().equals("兔子") && i % 2 == 0){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            boolean flag = gameOver(i);
            while (flag){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"--->跑了"+i+"步");
        }
    }

    //判断游戏胜利
    private boolean gameOver(int gepts){
        if (winner != null){
            return true;
        }
        if (gepts == 100){
            System.out.println("=============");
            winner = Thread.currentThread().getName();
            System.out.println("winner is "+ winner);
            return true;
        }
        System.out.println("=====w========");
        return false;
    }

    public static void main(String[] args) {
        ConcurrencyRace race = new ConcurrencyRace();
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }
}

实现Callable

在这里插入图片描述

package com.ty.threadAndRunableAndCallable;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CallableWebDownLoader implements Callable<Boolean> {
    private String url; //网图地址
    private String name;//保存地址

    public CallableWebDownLoader(String url,String name){
        this.url = url;
        this.name = name;
    }

    @Override
    public Boolean call() throws Exception {
        WebDownLoaderUseCallable callable = new WebDownLoaderUseCallable();
        callable.downLoader(url,name);
        System.out.println("文件名： "+ name);
        return true;
    }

    public static void main(String[] args) {
        CallableWebDownLoader c1 = new CallableWebDownLoader(
                "https://pic.rmb.bdstatic.com/bjh/914b8c0f9814b14c5fedeec7ec6615df5813.jpeg",
                "D:\\software\\JavaCode\\javaSE\\JavaSE01\\src\\com\\ty\\threadAndRunableAndCallable\\1.jpeg");
        CallableWebDownLoader c2 = new CallableWebDownLoader("" +
                "https://n.sinaimg.cn/sinakd2020723s/213/w2048h1365/20200723/3918-iwtqvyk4060964.jpg",
                "D:\\software\\JavaCode\\javaSE\\JavaSE01\\src\\com\\ty\\threadAndRunableAndCallable\\2.jpg");
        CallableWebDownLoader c3 = new CallableWebDownLoader(
                "https://file.ccmapp.cn/group1/M00/16/64/rApntl7CSdeAbpYqABArOjGaasg001.jpg",
                "D:\\software\\JavaCode\\javaSE\\JavaSE01\\src\\com\\ty\\threadAndRunableAndCallable\\3.jpg");

        ExecutorService es = Executors.newFixedThreadPool(1);
        es.submit(c1);
        es.submit(c2);
        es.submit(c3);
        es.shutdown();
    }
}
class WebDownLoaderUseCallable{
    public void downLoader(String url,String name) {
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO Exception, DownLoad Error!!!");
        }
    }
}

静态代理

真是对象和代理对象都要实现一个接口
代理对象要代理真是对象
好处：代理对象可以做真实对象做不了的事情，真实对象可以专注做自己的事情

package com.ty.threadAndRunableAndCallable;

public class staticProxy {
    public static void main(String[] args) {
        HappyCompany happyCompany = new HappyCompany(new You());
        happyCompany.HappyMarry();
    }

}
interface Marry{
    void HappyMarry();
}
//真实角色
class You implements Marry {
    @Override
    public void HappyMarry() {
        System.out.println("结婚了！我们结婚了！！！");
    }
}
//代理角色
class HappyCompany implements Marry{
    private Marry target;
    public HappyCompany(Marry target){
        this.target = target;
    }
    @Override
    public void HappyMarry() {
        after();
        this.target.HappyMarry();
        before();
    }

    private void after() {
        System.out.println("布置现场。。。。");
    }

    private void before() {
        System.out.println("收拾现场。。。。。");
    }
}

线程状态

在这里插入图片描述
五大状态：创建状态、就绪状态、阻塞状态、死亡状态、运行状态

线程执行流程

在这里插入图片描述

线程方法

在这里插入图片描述

停止线程

并不推荐使用stop()，destroy()
推荐线程自己停下来
建议使用一个标志位进行终止变量，flag=false 则终止线程

线程休眠Sleep

在这里插入图片描述

package com.ty.threadAndRunableAndCallable;

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

public class CountDown{


    private static void countDown(){
        int count = 10;
        while (true){
            try {
                Thread.sleep(1000);
                count--;
                if (count<0){
                    break;
                }
                System.out.println(count);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        //countDown();
        ControlTime();
    }

    //打印系统时间
    private static void ControlTime(){
        Date date = new Date(System.currentTimeMillis());//打印系统时间
        while (true){
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:dd:ss").format(date));
                date = new Date(System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

}

线程礼让 yield

在这里插入图片描述

package com.ty.threadAndRunableAndCallable;

public class ThreadYield {
    public static void main(String[] args) {
        Yield yield = new Yield();
        new Thread(yield,"a").start();
        new Thread(yield,"b").start();
    }
}
class Yield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程执行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程结束");
    }
}

合并线程Join

待此线程执行结束后，在执行其他线程，其他线程阻塞
可以想象成插队

package com.ty.threadAndRunableAndCallable;

public class ThreadJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("vip 来了"+i);
        }
    }

    public static void main(String[] args) {
        ThreadJoin join = new ThreadJoin();
        Thread thread = new Thread(join);
        thread.start();
        for (int i = 0; i < 20; i++) {
            if (i==10){
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("main----"+i);
        }
    }
}

线程状态观测

在这里插入图片描述
一个线程可以在给定时间点处于一个状态，这些状态时不反应任何操作系统线程状态的虚拟机状态

package com.ty.threadAndRunableAndCallable;

public class ThreadState {
    public static void main(String[] args) {
        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); // new

        thread.start();
        state = thread.getState();
        System.out.println(state);//run

        while (state != Thread.State.TERMINATED){//Thread.State.TERMINATED 线程不终止
            try {
                Thread.sleep(100);
                state = thread.getState();
                System.out.println(state);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

线程优先级

在这里插入图片描述

package com.ty.threadAndRunableAndCallable;

public class ThreadPriority {
    public static void main(String[] args) {
        getThreadPriority getThreadPriority = new getThreadPriority();
        Thread t1 = new Thread(getThreadPriority);
        Thread t2 = new Thread(getThreadPriority);
        Thread t3 = new Thread(getThreadPriority);
        Thread t4 = new Thread(getThreadPriority);
        Thread t5 = new Thread(getThreadPriority);
        Thread t6 = new Thread(getThreadPriority);

        t1.setPriority(1);
        t1.start();
        t2.setPriority(3);
        t2.start();
        t3.setPriority(5);
        t3.start();
        t4.setPriority(7);
        t4.start();
        t5.setPriority(Thread.MAX_PRIORITY);
        t5.start();
        t6.start();

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

守护线程demon

在这里插入图片描述

线程同步

并发：多个线程同时操作同一资源
由于同一进程的多个线程共享同一块内存空间，方便的同时也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，访问时，加入锁机制synchronized，当一个线程获得对象的排他锁，独占资源时，其他线程必选等待，使用后释放锁即可。
在这里插入图片描述

同步方法

在这里插入图片描述
在这里插入图片描述

同步块

同步块：synchronized() {}
在这里插入图片描述

同步块解决买票、银行取钱、集合不安全问题

//买票
package com.ty.threadAndRunableAndCallable.notSoft;

public class ThreadNotSoftQuestion {
    public static void main(String[] args) {
        buyTicket buyTicket = new buyTicket();
        new Thread(buyTicket,"aa").start();
        new Thread(buyTicket,"bb").start();
        new Thread(buyTicket,"cc").start();

    }
}

class buyTicket implements Runnable{

    private int num= 10;
    private boolean flag = true;

    @Override
    public void run() {
        while (flag){
            buy();
        }
    }

    private synchronized void buy(){
        if (num <= 0){
            flag = false;
            return;
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"---抢到了第 "+(num--)+"张票");
    }
}


package com.ty.threadAndRunableAndCallable.notSoft;

//银行取钱：两个人取钱
public class NotSoftBank {
    public static void main(String[] args) {
        Account account = new Account(100, "基金");
        Drawing you = new Drawing(account,50,"tt");
        Drawing girlFriend = new Drawing(account, 100, "yy");
        you.start();
        girlFriend.start();
    }
}
//银行
class Account{
    int money;// 余额
    String name;//卡号

    public Account(int money,String name){
        this.money = money;
        this.name = name;
    }
}

//模拟取钱
class Drawing extends Thread{
    private Account account;//账户
    private int drawingMoney;//取了多少
    private int nowMoney;//现在剩余

    public Drawing(Account account,int drawingMoney,String name){
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;

    }

    @Override
    public void run(){

        synchronized (account){

            if (account.money - drawingMoney < 0){
                System.out.println(Thread.currentThread().getName()+"余额不足，无法取出");
                return;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //余额
            account.money = account.money - drawingMoney;
            //手里
            nowMoney = nowMoney + drawingMoney;
            System.out.println(account.name+"余额为:"+account.money);
            System.out.println(this.getName()+"手里的钱："+nowMoney);
        }
    }
}



package com.ty.threadAndRunableAndCallable.notSoft;

import java.util.ArrayList;
import java.util.List;

public class NotSoftList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

死锁

在这里插入图片描述

避免死锁的四个方法

在这里插入图片描述

锁 Lock

在这里插入图片描述

synchronized和lock的区别

在这里插入图片描述

线程协作

##线程通信
在这里插入图片描述
均是Object类的方法，都只能在同步方法或者同步代码块中使用，否则就会抛出异常。

线程池

在这里插入图片描述
corePoolSize：核心池的大小
maximumPoolSize：最大线程数
keepAliveTime：线程没有任务时最多保持多长时间会终止
在这里插入图片描述

package com.ty.threadAndRunableAndCallable;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

//线程池
public class pool {
    public static void main(String[] args) {
        poolTest poolTest = new poolTest();
        ExecutorService es = Executors.newFixedThreadPool(10);
        es.submit(poolTest);
        es.submit(poolTest);
        es.submit(poolTest);
        es.submit(poolTest);
        es.shutdown();
    }
}
class poolTest implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
三月计划
关注
并发编程和多线程
why36910的博客
12-13 1013
文章目录并发编程和串行并发编程的目的：适合并发编程的场景并发编程的挑战之--频繁的上下文切换并发编程的挑战之--死锁并发编程的挑战--线程安全并发编程的挑战--资源的限制线程基础线程和进程的区别线程的状态及相互转换线程创建线程的挂起和恢复操作线程的中断操作(interrupt)线程的优先级守护线程 并发编程和串行 并发编程的目的： 让程序充分利用非计算机资源·、 加快程序响应速度（耗时任务、we...
多线程与并发
最新发布
_山月见光的博客
08-01 2540
程序：是为了完成某个特定的任务，而用某种语言编写的一组指令的集合，即指的是一段静态的代码，静态对象。进程：是程序的一次执行过程，或是一个正在运行的程序。是一个动态的过程：有它自身的产生、存在、和消亡的过程——生命周期。线程：进程可进一步细化为线程，是一个程序内部的执行的路径。若一个进程同一时间并行执行多个线程，就是支持多线程的。
多线程和并发。
孤芳不自赏
06-04 344
不推荐覆写start方法 启动线程前stop方法是不可靠的 不使用stop方法停止线程 有以下三个问题： 1、stop方法是过时的 2、stop方法会导致代码逻辑不完整 3、stop方法会破坏原子逻辑 如果期望终止一个正在运行的线程，则不能使用已经过时的stop方法，需要自行编码实现，如此即可保证原子逻辑不...
java多线程和并发.pdf
12-02
首先，关于多线程和并发编程的背景，我们可以从几个方面进行了解： 1. 高并发请求的Online应用指的是那些需要同时处理成千上万的用户请求的应用程序，这些应用需要具备高度的响应性和并发处理能力，常见的场景包括...
JAVA多线程和并发基础面试问答(翻译)
09-04
多线程和并发问题是Java技术面试中面试官比较喜欢问的问题之一。在这里，从面试的角度列出了大部分重要的问题，但是你仍然应该牢固的掌握Java多线程基础知识来对应日后碰到的问题
各大公司校招笔试面试多线程和并发历年真题总结
12-27
尤其是在校招笔试面试中，对于理解多线程和并发的真题，往往是衡量一个程序员专业水平的重要指标。本文将详细探讨多线程和并发中的一些重要知识点，包括缓存一致性问题、volatile关键字的内存语义等，这些内容在各大...
java多线程和并发
12-02
在现代计算机系统中，多核处理器的普及使得并发执行任务成为可能，而Java作为一门跨平台的编程语言，提供了丰富的工具和机制来支持多线程编程和并发控制。 1. **线程基础**： - **线程定义**：线程是程序执行的...
Java多线程之并发工具类
12-22
Java并发工具类是Java多线程编程中必不可少的一部分，它们为开发者提供了更加高效和灵活的线程同步机制。本文将详细介绍三个重要的并发工具类：CountDownLatch、CyclicBarrier和Semaphore。 首先，CountDownLatch是...
多线程 与并发
wanglei1598的博客
04-10 5442
官方文档https://docs.oracle.com/javase/tutorial/essential/concurrency/index.html 推荐《Java高并发编程详解：多线程与架构设计》 推荐《Java高并发编程详解：深入理解并发核心库》 有很多工具的基准测试 同步和异步 所谓同步就是一个任务的完成需要依赖另外一个任务时，只有等待被依赖的任务完成后，依赖的任务才能算完成，这是一种可靠的任务序列。要么成功都成功，失败都失败，两个任务的状态可以保持一致。 所谓异步是...
多线程与并发（一）
XIONGXING_xx的博客
03-17 214
并发、进程、线程一、什么是并发？并发概念二、什么是进程？1.进程与程序的联系2.区别3.特点4.操作系统如何进行进程管理？5.进程都有那些状态？三、什么是线程？1.为啥使用多线程？2.使用线程优点3.使用线程缺点4.多线程(并发) 一、什么是并发？ 并发概念 1.两个或更多的任务（独立活动）同时发生（进行）：一个程序同时执行多个独立的任务。 2.单核cpu某个时刻只能执行一个任务：由操作系统调度，每秒钟进行所谓的“任务切换”。 3.并发的假象（伪并发不是真正的并发）；这种切换（上下文切换1，状态信息）是要有
Java多线程与并发
热门推荐
lydms的博客
06-21 1万+
假设线程A已经拥有了某个对象（不是类）的锁，而其它线程B、C想要调用这个对象的某个 synchronized方法（或者块），由于B、C线程在进入对象的 synchronized方法（或者块）之前必须先获得该对象锁的拥有权，而恰巧该对象的锁目前正被线程A所占用，此时B、C线程就会被阻塞，进入一个地方去等待锁的释放，这个地方便是该对象的锁池。假设线程A调用了某个对象的wat（）方法，线程A就会释放该对象的锁，同时线程A就进入到了该对象的等待池中，进入到等待池中的线程不会去竞争该对象的锁。
并发与多线程
Andrew.J
11-16 1073
多线程知识点 多线程协作时，因为对资源的锁定与等待会产生死锁，这里需要了解产生死锁的四个基本条件，要明白竞争条件与临界区的概念，知道可以通过破坏造成死锁的 4 个条件来防止死锁。 前面讲过进程间的通信方式，这里还要知道线程间的通信方式，通信主要指线程之间的协作机制，例如 wait、notify 等。 还需要知道 Java 为多线程提供的一些机制，例如 ThreadLocal 用来保存线程独享的数据， Fork/Join 机制用于大任务的分割与汇总，Volatile 对多线程数据可见性的保证，以及线程的中断
Java 知识合集 ｜ 多线程与并发
编程洪同学
07-22 584
本篇涵盖了多线程编程中的关键内容，对于理解并发编程的原理和实践有很好的指导作用。继续学习和实践多线程编程将有助于你在并发环境下开发出更稳健、高效的应用程序。
并发和多线程
Learning
12-18 500
总结java并发和多线程的核心概念和知识点，以及开发时的注意事项。
多线程和并发有什么区别
07-12
多线程和并发是两个相关但不完全相同的概念。 多线程指的是在同一进程中同时运行多个线程，每个线程都是独立的执行单元，可以并行地执行不同的任务。 而并发则指的是多个任务同时执行，在某个时刻，可能有多个任务...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值