java_多线程

最新推荐文章于 2023-01-04 19:55:48 发布
最新推荐文章于 2023-01-04 19:55:48 发布
阅读量99 收藏
点赞数
分类专栏： java 笔记 文章标签： 多线程 1024程序员节
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51497041/article/details/120894571
版权
笔记 同时被 2 个专栏收录
39 篇文章 2 订阅
订阅专栏
java
27 篇文章 0 订阅
订阅专栏

 1.介绍

 不建议使用继承Tread的方法去创建多线程，java是单继承，这样可避局限性

推荐使用实现接口的方式

使用Callable创建线程

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableThreadTest implements Callable<Integer>{
    public static void main(String[] args)
    {
        CallableThreadTest ctt = new CallableThreadTest();
        FutureTask<Integer> ft = new FutureTask((Callable) ctt);
        for(int i = 0;i < 100;i++)
        {
            //输出的均为当前线程的名字
            System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);
            if(i==20)
            {
                new Thread(ft,"有返回值的线程").start();
            }
        }
        try
        {
            System.out.println("子线程的返回值："+ft.get());
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        } catch (ExecutionException e)
        {
            e.printStackTrace();
        }
    }
    @Override
    public Integer call() throws Exception
    {
        int i = 0;
        for(;i<100;i++)
        {
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
        return i;
    }
}

2.Lamda 表达式

 

 

 

 

3. 观测线程状态

线程状态
NEWRUNNABLEBLOCKEDWAITINGTIMED_WAITINGTERMINATED
Thread.start();就绪状态和运行状态wait，io操作 read和write；sleep，joinsleep，join死亡状态
public class TestState {
    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);

        //开启线程
        thread.start();
        //刷新state的值
        state = thread.getState();
        System.out.println(state);

        while (state != Thread.State.TERMINATED){

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

            state = thread.getState();
            System.out.println(state);
        }
    }
}

4.守护线程

package Tread;

public class TestShouhu {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();
        //设置守护线程并启动
        Thread thread = new Thread(god);
        thread.setDaemon(true);
        thread.start();
        //启动默认线程
        new Thread(you).start();
    }
}
    class God implements Runnable{
        @Override
        public void run(){
            while (true){
                //守护线程会随着用户线程的结束而自动结束（等一会儿守护线程才会结束）
                System.out.println("守护线程……");
            }
        }
    }
    class You implements Runnable{
        @Override
        public void run(){
            for (int i = 0;i<300;i++){

                System.out.println("线程还活着");
            }
            System.out.println("==============线程死了==========");
        }
    }

5.线程同步

每个线程在自己的工作内存交互；

并发：多个线程想访问同一个对象

每个对象都有一把锁

解决并发：队列和锁

 

        Obj是对象，锁住的是同步的资源的对象

        用synchronized修饰的类，是直接把类锁了

         

package Tread;

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

public class Tongbu {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();

        for (int i = 0 ;i<100;i++){
            new Thread(()->{
                //此处是同步块，（）里存放公共资源（对象）
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        try{
            Thread.sleep(2000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

线程安全的集合 CopyOnWriteArrayList

package Tread;

import java.util.concurrent.CopyOnWriteArrayList;

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

6.死锁

 死锁的四个必要条件

 

package Tread;

public class SiSuo {
    public static void main(String[] args) {
        Makeup g1 = new Makeup(0,"女孩1");
        Makeup g2 = new Makeup(1,"女孩2");

        g1.start();
        g2.start();
    }
}

    //口红
    class Lipstick{

    }
    //镜子
    class Mirror{

    }

    class Makeup extends Thread{

        //需要的资源只有一份，用Static来保证只有一份
         static Lipstick lipstick= new Lipstick();
         static Mirror mirror = new Mirror();

        int choice;//选择
        String girlName;//使用化妆品的人
        Makeup(int choice,String girlName){
            this.choice = choice;
            this.girlName = girlName;
        }
        @Override
        public  void run(){
            try {
                makeup();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //化妆，互相持有对方的锁，就是需要拿到对方的资源
        private  void makeup() throws InterruptedException{
            if (choice == 0){
                
                //这样会导致死锁的产生
                //解决办法是：把mirror锁移出lipstick锁
                synchronized (lipstick){
                    System.out.println(this.girlName+"获得口红的锁");
                    Thread.sleep(2000);
                    synchronized (mirror){
                        System.out.println(this.girlName + "获得镜子的锁");
                    }
                }
            }else{
                
                //这样会导致死锁的产生
                //解决办法是：把mirror锁移出lipstick锁
                synchronized (mirror){
                    System.out.println(this.girlName+"获得镜子的锁");
                    Thread.sleep(1000);
                    synchronized (lipstick){
                        System.out.println(this.girlName+"获得口红的锁");
                    }
                }
            }
        }
    }

7. Lock 锁（可重入锁）

 synchronized与Lock的对比

package Tread;

import java.util.concurrent.locks.ReentrantLock;

public class Lock {
    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }
}
class TestLock2 implements Runnable{
    int tickeNums = 10;

    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while(true){
            try {
                //加锁
                lock.lock();
                if(tickeNums>0){
                    try {
                        Thread.sleep(1000);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                    System.out.println(tickeNums--);
                }else {
                    break;
                }
            }finally {
                //解锁
                lock.unlock();
            }
        }
    }
}

8. 生产者与消费者

 生产者和消费者：管程法和信号灯法区别

 方法一：管程法

package Tread;

public class ProductorConsumer {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();

        new Productor(container).start();
        new Consumer(container).start();
    }
}
//生产者
class Productor extends Thread{
    SynContainer container;
    public Productor(SynContainer container){
        this.container = container;
    }

    @Override
    public void run() {
        for (int i = 0;i<100;i++){
            container.push(new Chicken(i));
            System.out.println("生产了"+i+"只鸡");
        }
    }
}
//消费者
class Consumer extends Thread{
    SynContainer container;
    public Consumer (SynContainer container){
        this.container = container;
    }

    @Override
    public void run() {
        for (int i = 0;i<100;i++){
            System.out.println("消费了-->"+container.pop().id+"只鸡");
        }
    }
}
//产品
class Chicken{
    int id;
    public Chicken(int id){
        this.id = id;
    }
}
//缓冲区
class SynContainer{
    Chicken[] chickens = new Chicken[10];
    int count =0;
    public synchronized void push(Chicken chicken){
        if (count==chickens.length){
            try{
                this.wait();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }

        chickens[count]=chicken;
        count++;
        this.notifyAll();
    }
    public synchronized Chicken pop(){
        if (count == 0){
            try{
                this.wait();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
        count--;
        Chicken chicken = chickens[count];

        this.notifyAll();
        return chicken;
    }
}

方法二：信号灯法

package Tread;

public class ProductorConsumer2 {
    public static void main(String[] args) {
        TV tv = new TV();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}
//演员
class Player extends Thread{
    TV tv;
    public Player(TV tv){
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i%2==0){
                this.tv.play("快乐大本营播放中");
            }else{
                this.tv.play("抖音：记录美好生活");
            }
        }
    }
}
//观众
class Watcher extends Thread{
    TV tv ;
    public Watcher (TV tv){
        this.tv=tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            tv.watch();
        }
    }
}
//电视
class TV{
    String voice;
    boolean flag = true;
    public synchronized void play(String voice){
        if (!flag){
            try{
                this.wait();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了："+voice);
        this.notify();
        this.voice = voice;
        this.flag = !this.flag;
    }
    public synchronized void watch(){
        if(flag){
            try {
                this.wait();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
        System.out.println("观看了："+voice);
        this.notifyAll();
        this.flag = ! this.flag;
    }
}

 9.线程池

 

 实现Runable接口创建线程池

package Tread;

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

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

        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        service.shutdown();
    }
}
class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

Future模式创建线程池分析

 Future创建线程池

package Tread;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class XianChengChi_Callable {
    //静态方法不能调用非静态方法，所以这里需要是静态的
    public static class Tasker implements Callable<String>{

        @Override
        public String call() throws Exception {
            return "hello";
        }
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //创建线程池并设置线程数
        ExecutorService threadPool = Executors.newFixedThreadPool(3);
        List<Future<String>> futures = new ArrayList<Future<String>>();
        Future<String> res = null;
        for(int i=0;i<5;i++){
            res = threadPool.submit(new Tasker());
            futures.add(res);
        }
        threadPool.shutdown();
        for(Future<String> future:futures){
            System.out.println(future.get());
        }
    }
}

巡山小钻风つ
关注
专栏目录
java多线程查询_java多线程查询
weixin_33370255的博客
02-20 3432
标签：由于最近工作遇到性能问题，尝试研究用多线程来实现，结果速度快了好几倍下面是多线程查询的部分代码，提供给大家参考下：线程类：带返回值的类要实现Callable接口，具体业务逻辑没有实现，只是写了个空方法在里面package com.sanfy.demo.thread;import java.util.List;import java.util.Map;import java.util.conc...
rabbitmq java 多线程_RabbitMQ入门_05_多线程消费同一队列
weixin_39667652的博客
02-16 2099
A. 多线程消费同一队列消费一条消息往往比产生一条消息慢很多，为了防止消息积压，一般需要开启多个工作线程同时消费消息。在 RabbitMQ 中，我们可以创建多个 Consumer 消费同一队列。示意图如下：gordon.study.rabbitmq.workqueue.Sender.javapublic class Sender {private static final String QUEUE...
万字图解Java多线程
热门推荐
qq_35598736的博客
09-06 6万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
Java_多线程
遇见你 的博客
05-01 521
实现多线程 线程同步 生产者消费者 实现多线程（324） 1.1 进程 进程:是正在运行的程序 是系统进行资源分配和调用的独立单位 每一个进程都有它自己的内存空间和系统资源 1.2 线程 线程：是程序中的单个顺序控制流，是一条执行路径 单线程：一个进程如果只有一条执行路径，则称为单线程程序 多线程:一个进程如果由多条执行路径，则称为多线程程序 举例： 记事本程序 扫雷程序 1.3 多线程的实现方式 方式1：继承Thread类 定义一个类MyThread继承Thread类 在
Java_多线程与并发编程总结.doc
04-14
Java多线程与并发编程是Java开发中至关重要的一部分，它涉及到如何高效地利用CPU资源，以实现程序的并行执行。在操作系统层面，多任务和多进程是通过分配不同的内存空间来实现的，而线程则共享同一进程的内存，这...
java多线程设计模式_java_设计模式_多线程_多线程课题_
09-29
Java多线程设计模式是Java开发中的核心概念，它涉及到如何高效、安全地在多个执行线程之间共享资源和协调任务。设计模式是解决特定问题的成熟方案，它们是编程经验的结晶，可以帮助开发者在面临多线程挑战时快速找到...
JAVA-JavaThreadProgramming-Sams.zip_JAVA 设计_java 多线程_java 线程_多线程
09-14
Java多线程允许程序同时执行多个任务，这极大地提高了程序的效率和响应性。在Java中，线程可以分为两类：用户线程和守护线程。用户线程是应用程序的主要执行单元，而守护线程则服务于用户线程，如垃圾收集器就是典型...
java_多线程设计模式
01-16
java_多线程设计模式，一部挺适合新手了解并且使用java多线程的入门教程
tcp_test.rar_java tcp 多线程_java tcp 线程_tcp 多线程_tcp线程_多线程 TCP
09-14
本项目"tcp_test.rar"似乎是一个关于Java实现TCP多线程传输的实例，它涵盖了发送方和接收方的并发处理。 首先，让我们了解TCP多线程的概念。在单线程TCP服务器中，服务器接收到一个客户端连接后，会阻塞等待该连接...
字符串去除重复字符
java后端攻城狮
08-28 1876
方法一： import java.util.LinkedHashSet; public class Solution { public String handle(String str) { int len = str.length(); char[] c = str.toCharArray(); //用Set可以去除重复元素， //LinkedHashSet 可以保存输入顺序 //hashSet 可以快速读访问s.
git小乌龟下载及汉化
java后端攻城狮
08-07 1405
在文件夹里，右键选择 tortoiseGit——>settings修改语言。
vue学习
java后端攻城狮
04-09 1191
创建空文件夹，用IJ打开
super && 自定义异常
java后端攻城狮
08-12 876
使用自定义异常 类MyException继承了Exception类，需要你定义一个包含字符串类型的有参构造函数，用来输出异常的详细消息字符串。 类Solution包含validate方法，传入一个整型的num，你需要对其传入的参数进行判断，当数字包含 0 到 100 之间的任意数字，则输出该数字，若输入的数字不在该范围，则抛出自定义异常MyException并打印输出The number you entered is not legal。 public class MyExce...
JavaScript学习笔记
java后端攻城狮
01-01 682
1
Maven使用
java后端攻城狮
04-07 608
Maven传送门 提取码：60v8 4.2 Maven环境变量配置 M2_MAVEN 地址是：maven的bin目录 MAVEN_HOME 地址：maven目录 path中:%MAVEN_HOME%\bin 4.3 镜像 mirror 国内建议阿里镜像： <mirror> <id>nexus-aliyun</id> <mirrorOf>*,!jeecg,!jeecg-snapshots&...
javaweb
java后端攻城狮
11-08 546
动态web流程
服务端渲染和客户端渲染
最新发布
java后端攻城狮
01-04 400
servlet开发 浏览器请求servlet，servlet在服务端生成html 响应给浏览器，浏览器展示html的内容，这个过程就是服务端渲染。 输入url——>请求到tomcat——Servlet / jsp来解析解析用户请求并处理——>服务端渲染生成html——>通过http响应给浏览器htmlAJAX技术兴起出现客户端渲染，客户端（浏览器）实用AJAX向服务端发起http请求，获取得到数据，客户端拿着数据开始渲染html网页，生成Dom元素并最终将网页内容展现给用户 输入url——>请求到tomc
让程序并行运行多次启动
java后端攻城狮
08-06 383
IJ勾选可并行选项之后就可以运行程序后，修改端口再此运行，就能同时有两个这个程序运行。
Java实现多线程下载工具
"疯狂java实例-第11章_多线程下载工具" 在Java编程领域，多线程下载工具的实现是一项重要的技能，它能够帮助用户高效地管理和下载网络资源。本章节主要聚焦于如何使用Java来开发一个支持HTTP协议的多线程下载工具，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值