java多线程

最新推荐文章于 2023-11-13 21:07:01 发布
最新推荐文章于 2023-11-13 21:07:01 发布
阅读量235 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55804942/article/details/125830531
版权

进程与线程

进程通常指的是一个软件列如QQ.exe等。一个进程里面有多个线程，至少包含一个线程，java中默认有两个线程（main，GC）

java中开启线程三种方式：Thread,Runnable,callable

java不可以开启线程

通过group.add()把当前线程添加到当前线程组，调用本地方法start0()，调用的是底层c++，因为java无法直接操作硬件，java是运行在虚拟机上的。所以需要通过c++完成。

    public synchronized void start() {
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }

    private native void start0();

并发编程：并发与并行

并发编程的本质：充分利用CPU的资源

并发：多个线程操作同一个资源

        一核CPU，模拟多条线程

并线：多个一块行动

       多核CPU，模拟多条线程可以同时执行

public static void main(String[] args) {
        //获得cpu核数
        System.out.println(Runtime.getRuntime().availableProcessors());
    }

线程的状态

//线程新生
NEW,
//运行
RUNNABLE,
//阻塞     
BLOCKED,
//等待
WAITING,
//超时等待
TIMED_WAITING,
//终止
TERMINATED;

wait/sleep的区别

  • 类不同
    • wait是Object类中的，sleep是Threa中的
  • 锁的释放
    • wait不释放锁，sleep不释放锁
  • 使用范围不同
    • wait必须在同步代码块中才能使用，sleep不做限制
  • wait/sleep都需要捕获异常InterruptedException中断异常

Lock锁

lock的使用

 Lock l = ...;
 l.lock();
 try {
   // access the resource protected by this lock
 } finally {
   l.unlock();
 }

lock接口的实现类

ReentrantLock：可重入锁

ReentrantReadWriteLock.ReadLock：读锁

ReentrantReadWriteLock.WriteLock：写锁

ReentrantLock的构造方法：

默认是非公平锁

//非公平锁
public ReentrantLock() {
        sync = new NonfairSync();
}
//公平锁
public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
}

synchronized和lock的区别

  1. synchronized是java中的关键字，lock是一个java类
  2. synchronized无法判断获得锁的状态，lock可以判断是否获得锁
  3. synchronized会自动释放锁，lock需要手动释放锁，不释放锁会死锁
  4. 使用synchronized 线程1获得了锁后面的线程将会等待，线程1要是阻塞后面的线程就会一直等待。lock锁使用tryLock()就不会等待
  5. synchronized可重入锁，不可以中断，非公平锁，lock可重入锁，可以中断，可以字节设置非公平锁和公平锁
  6. synchronized适合少量的代码同步问题，lock适合锁大量的同步代码

生成者与消费者

synchronized：

public class Demo01 {
    public static void main(String[] args) {
        Data data  = new Data();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.incte();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.derce();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
    }
}
class Data{
    private Integer num = 0;
    public synchronized void incte() throws InterruptedException{
        while(num != 0 ){
            this.wait();
        }
        num ++;
        System.out.println(Thread.currentThread().getName()+" -->"+ num);
        this.notifyAll();
    }
    public synchronized void derce() throws InterruptedException{
        while(num == 0 ){
            this.wait();
        }
        num --;
        System.out.println(Thread.currentThread().getName()+" -->"+ num);
        this.notifyAll();
    }
}

JUC：

通过lock找到Condition，

Lock替换synchronized方法和语句的使用， Condition取代了对象监视器方法的使用。

代码演示

public class Demo01 {
    public static void main(String[] args) {
        Data data  = new Data();
        new Thread(()->{for (int i = 0; i < 10; i++)data.incte();},"A").start();
        new Thread(()->{for (int i = 0; i < 10; i++)data.derce();},"B").start();
        new Thread(()->{for (int i = 0; i < 10; i++)data.incte();},"C").start();
        new Thread(()->{for (int i = 0; i < 10; i++)data.derce();},"D").start();
    }
}
class Data{
    private Integer num = 0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    public  void incte(){
        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 derce(){
        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();
        }
    }
}

Condition实现精准唤醒

public class Demo02 {
    public static void main(String[] args) {
        DataTwo dataTwo = new DataTwo();
        new Thread(()->{for (int i = 0; i < 10; i++)dataTwo.prinA();},"A").start();
        new Thread(()->{for (int i = 0; i < 10; i++)dataTwo.prinB();},"B").start();
        new Thread(()->{for (int i = 0; i < 10; i++)dataTwo.prinC();},"C").start();
    }
}
class DataTwo{
    Lock l = new ReentrantLock();
    Condition condition = l.newCondition();
    private int num = 1;
    public void prinA(){
        l.lock();
        try {
            while (num != 1){
                condition.await();
            }
            System.out.println(Thread.currentThread().getName()+"正在执行");
            num=2;
            condition.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            l.unlock();
        }
    }
    public void prinB(){
        l.lock();
        try {
            while (num != 2){
                condition.await();
            }
            System.out.println(Thread.currentThread().getName()+"正在执行");
            num=3;
            condition.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            l.unlock();
        }
    }
    public void prinC(){
        l.lock();
        try {
            while(num != 3){
                condition.await();
            }
            System.out.println(Thread.currentThread().getName()+"正在执行");
            num = 1;
            condition.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            l.unlock();
        }
    }
}

CopyOnWriteArrayList

在并发下ArrayList是线程不安全的，会出现异常java.util.ConcurrentModificationException（并发修改异常）

public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,4));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }

那么怎么解决这个并发修改异常问题呢？

方法一

list集合中Vector集合是线程安全的所以可以使用Vector解决

List<String> list = new Vector<String>();

方法二

可以使用Collections中的synchronizedList()将ArrayLIst改变为线程安全的

List<String> list = Collections.synchronizedList(new ArrayList<>());

  方法三

使用CopyOnWriteArrayList

List<String> list = new CopyOnWriteArrayList<>();

使用Vector本事就是线程安全的在添加数据的时候就是同步的，

使用Collections.synchronizedList()就是将传过去的list添加同步锁

使用CopyOnWriteArrayList读写分离，在写入数据的时候复制一份并且在他的底层是使用lock锁

 推荐使用CopyOnWriteArrayList因为使用synchronized效率会比较低但。

如果需要将map改变为线程安全需要使用到ConcurrentHash Map()

Map<String,Object> map = new ConcurrentHashMap<String,Object>();

Collable

Callable接口类似于Runnable，因为它们都是为其实例可能由另一个线程执行的类设计的。 然而，A Runnable不返回结果，也不能抛出被检查的异常。

Callable与Runnable不同于，Callable可以抛出异常，使用的方法不同Callable使用call方法，Callable可以有返回值

ReadWriteLock(读写锁)

java并发包中ReadWriteLock是一个接口，主要有两个方法

public interface ReadWriteLock {
    Lock readLock();
    Lock writeLock();
}

 实现类：ReadWriteLockView，ReentrantReadWriteLock

readLock是读锁，writeLock是写锁，使用ReadWriteLock可以更加细粒度控制

public class ReadWriteLockTest {
    static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

    public static void main(String[] args) {
        Date date = new Date();
        Test test = new Test();
        new Thread(()->test.start(true,sdf.format(date)),"write-----1").start();//读
        new Thread(()->test.start(true,sdf.format(date)),"write-----2").start();//读
        new Thread(()->test.start(false,sdf.format(date)),"read-----2").start();//写
        new Thread(()->test.start(false,sdf.format(date)),"read-----1").start();//写
        new Thread(()->test.start(false,sdf.format(date)),"read-----3").start();//写
    }

}
class Test{
        ReadWriteLock rel = new ReentrantReadWriteLock();//构建ReentrantReadWriteLock使锁细腻话
        //创建读锁
        Lock readLock = rel.readLock();
        //创建写锁
        Lock writeLock = rel.writeLock();
    public <T> void start(boolean flse, T t){
        if(flse)read(t);else write(t);
    }
    //读方法
    public <T> void read(T t){
        readLock.lock();//使用读锁
        try {
            System.out.println("线程"+Thread.currentThread().getName()+"正在读，当前时间是："+t);
            TimeUnit.SECONDS.sleep(2);//停滞两秒
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readLock.unlock();//释放读锁
        }
    }
    //写方法
    public <T> void write(T t){
        writeLock.lock();//使用读锁
        try {
            System.out.println("线程"+Thread.currentThread().getName()+"正在写，当前时间是："+t);
            TimeUnit.SECONDS.sleep(2);//停滞两秒
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            writeLock.unlock();//释放读锁
        }
    }
}

线程池

使用线程池的优点：

  • 降低资源的消耗，通过重复利用已创建的线程降低线程创建和销毁造成的消耗
  • 提高影响速度，通过重复利用已创建的线程降低线程创建和销毁造成的消耗
  • 提高线程的可管理性，

线程池的使用

JDK 5.0起提供了线程池相关API：ExecutorService 和Executors

ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor

创建四种方式：

  • newCachedThreadPool：创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待

public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("threadName;"+Thread.currentThread().getName());
                }
            });
        }
    }
  • newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
public static void main(String[] args) {
    //1.创建可固定长度的线程池
    ExecutorService newExecutorService = Executors.newFixedThreadPool(3);
    //创建了10个线程
    for (int i = 0; i < 10; i++) {
        int temp = i;
            newExecutorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("threadName;"+Thread.currentThread().getName()+",i"+temp);
                }
        });
    }
}
  • newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。延迟执行示例
 public static void main(String[] args) {
        //1.创建可定时线程池
        ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(5);
        for (int i = 0; i < 10; i++) {
            final int temp = i;
            newScheduledThreadPool.schedule(new Runnable() {
                public void run() {
                    System.out.println("i:" + temp);
                }
            }, 3, TimeUnit.SECONDS);//时间数值，时间单位
        }

    }
  • newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行需要关闭
public static void main(String[] args) {
        //1.创建单线程
        ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            newSingleThreadExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("index:" + index);
                    try {
                        TimeUnit.SECONDS.sleep(2);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }

        newSingleThreadExecutor.shutdown();
    }

搬运代码的码农
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java jvm 线程数_一台 Java 服务器到底可以跑多少个线程？
weixin_39763953的博客
02-16 1161
一台Java服务器能跑多少个线程？这个问题来自一次线上报警如下图，超过了我们的配置阈值。京东自研UMP监控分析打出jstack文件，通过IBM Thread and Monitor Dump Analyzer for Java工具查看如下：IBM Thread and Monitor Dump Analyzer for Java共计1661个线程，和监控数据得出的吻合。但这个数量应该是大了，我们都...
java 多线程
11-07
java 多线程 知识相关，主要是介绍 java 多线程相关的知识
一、java学习 | 多线程【进阶】
AG150的博客
05-22 527
JUC：java.utils.concurrent 并发编程业务：普通的线程代码 ThreadRunnable 没有返回值、效率相比Callable较低。
java默认有几个线程
RT_0114的博客
06-17 828
2个。main线程和GC线程。
java能启动多少个线程_Java启动时默认创建了多少线程
weixin_35363591的博客
02-27 535
Java启动时默认创建了多少线程，其实在Java本身启动时会创建若干个线程，除了main线程之外，还有Monitor Ctrl-Break，Signal Dispatcher，Finalizer，Reference Handler。package org.sun.sample.pojo;import java.lang.management.ManagementFactory;import jav...
java多线程（超详细）
热门推荐
zdl66的博客
08-14 9万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
Java多线程详解及示例
07-20
本文将深入探讨Java多线程编程的重要性和使用方法。介绍多线程概念，讨论多线程的优势，并提供实际示例。此外，还将探讨多线程编程中的常见问题以及如何避免这些问题。通过本文，您将获得对Java多线程编程的全面理解...
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
Java多线程编程技术
03-26
《Java多线程编程核心技术》建议猿友们读两遍，因为其写得没有那么抽象，第一遍有些概念不是很理解，可以先跳过并记录起来，第一遍阅读的目的主要是了解整个架构。第二遍再慢慢品味，并贯穿全部是指点来思考，并将...
多线程两种实现方式Java
07-28
多线程两种实现方式Java，MLDN,实训课程中的多线程
JAVA最多支持多少个线程
xcwll314的专栏
07-24 7524
1.  java的线程开启，默认的虚拟机会分配1M的内存，但是在4G的windows上线程最多也就开到300多 ，是因为windows本身的一些限制导致。 2.  虚拟机给每个线程分配的内存（栈空间）是由虚拟机参数-Xss来指定的，在不同平台上对应的默认大小可以 在oracle的官方文档上查询到： http://docs.oracle.com/cd/E13150_01/jrockit_jv
编程必备：JAVA多线程详解
拾一二的博客
06-14 6920
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
Java多线程详解，一篇文章彻底搞懂多线程！！！
最新发布
ZhaZha_Yi的博客
11-13 84
任何接口如果只包含唯一一个抽象方法，那么他就是一个函数式接口；
Java启动时默认创建了多少线程
weixin_34372728的博客
04-11 582
2019独角兽企业重金招聘Python工程师标准>>> ...
深入理解Java多线程（一）
qq_37438740的博客
08-11 4万+
关于java多线程的概念以及基本用法：java多线程基础 1，停止线程 停止线程意味着在线程执行完之前停止正在做的操作，即立刻放弃当前的操作，这并不容易。停止线程可以用Thread.stop()方法，但是这个方法不安全，所以不建议使用，还有一个方法就是Thread.interrupt()方法，但是这个方法不会终止一个正在运行的线程，需要添加一个判断才可以完成线程的停止 1.1，...
java多线程-JUC
weixin_43391584的博客
12-30 189
JUC之java高并发-多线程学习 1. JUC定义 源码 + 官方文档 java.util工具包下的三个接口及工具类 **业务：**普通的线程代码：Thread **Runnable接口：**没有返回值、效率相比于Callable较低 2. 线程和进程 线程、进程使用一句话来概括 **进程：**一个程序，如QQ.exe，Music.exe程序的集合 一个进程往往可以包含多个线程，至少会包含一个！ java默认有两个线程：main，GC **线程：**比如当前开启了一个Typora进程，在其中
线程池默认多少个线程_我需要多少个线程？
最佳 Java 编程
06-06 2488
线程池默认多少个线程 这取决于您的应用程序。 但是，对于那些希望对如何从生产站点购买的所有昂贵内核中挤出大量资金的人，请多多包涵，我将阐明围绕多线程 Java应用程序的奥秘。 内容针对最典型的Java EE应用程序进行了“优化”，该应用程序具有Web前端，允许最终用户在应用程序内发起许多小交易。 每个事务的很大一部分都在等待一些外部资源。 例如从数据库或任何其他集成数据源返回的查询。 但是大多...
Java 启动一个main程序时，有多少个线程
chenxi004的博客
03-19 3770
简单启动一个main程序时，有多少个线程被创建呢？ public class OnlyMain { public static void main(String[] args) { //虚拟机线程管理的接口 ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean(); ThreadInfo...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值