JAVA并发编程

最新推荐文章于 2023-08-03 20:45:00 发布
最新推荐文章于 2023-08-03 20:45:00 发布
阅读量122 收藏
点赞数
文章标签： java 并发编程 JUC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/good_szl/article/details/125364865
版权

JAVA并发编程

JAVA创建线程的3种方式

继承Thread

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

Runnable

没有返回值

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

Callable

有返回值

public class ThreadTest {
    public static void main(String[] args) {
        Callable<Integer> myCallable = new MyCallable();    // 创建MyCallable对象
        FutureTask<Integer> ft = new FutureTask<Integer>(myCallable); //使用FutureTask来包装MyCallable对象
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 30) {
                Thread thread = new Thread(ft);   //FutureTask对象作为Thread对象的target创建新的线程
                thread.start();                      //线程进入到就绪状态
            }
        }

        System.out.println("主线程for循环执行完毕..");
        
        try {
            int sum = ft.get();            //取得新创建的新线程中的call()方法返回的结果
            System.out.println("sum = " + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}


class MyCallable implements Callable<Integer> {
    private int i = 0;

    // 与run()方法不同的是，call()方法具有返回值
    @Override
    public Integer call() {
        int sum = 0;
        for (; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            sum += i;
        }
        return sum;
    }
}

进程和线程

  • 进程： 资源分配的最小单位，具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。
  • 线程：操作系统进行运算调度的最小单位，被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。同一进程中的多条线程将共享该进程中的全部系统资源，如虚拟地址空间，文件描述符和信号处理等等。但同一进程中的多个线程有各自的调用栈，自己的寄存器环境，自己的线程本地存储。

一个进程可以包含多个线程，至少一个。

java默认有两个线程，一个main，一个垃圾回收。

java无法直接操作硬件，要通过C++的native方法来开启线程

并发和并行

  • 并发：把任务在不同的时间点交给处理器进行处理。在同一时间点，任务并不会同时运行。
  • 并行：把每一个任务分配给每一个处理器独立完成。在同一时间点，任务一定是同时运行。

并发编程是为了充分利用CPU的资源。

线程的状态

线程的六种状态

在这里插入图片描述

public enum State {
    // 新建
    NEW,

    // 运行
    RUNNABLE,

    // 阻塞
    BLOCKED,

    // 等待，一直等待
    WAITING,
	
    // 超时等待
    TIMED_WAITING,

    // 终止
    TERMINATED;
}

wait和sleep

  • wait来自于object类，会释放锁，不需要捕获异常，一般在同步块中使用

  • sleep来自于thread类，不会释放锁，需要捕获异常

sleep的方式

TimeUnit.DAYS.sleep(1);
TimeUnit.SECONDS.sleep(10);

Lock

锁分为公平锁和非公平锁

公平：每个线程获取锁的机会是平等的

非公平：每个线程获取锁的机会是不平等的

无锁情况下

不加锁时，最终剩余的结果和期望的结果有偏差

public class Ticket {
    private int num = 50;

    public void sale(){
        if(num > 0){
            System.out.println(Thread.currentThread().getName() + "剩余" + --num + "张票" );
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        new Thread(() ->{
            sale10(ticket);
        }, "A").start();
        new Thread(() ->{
            sale10(ticket);
        }, "B").start();

        new Thread(() ->{
            sale10(ticket);
        }, "C").start();
    }

    private static void sale10(Ticket ticket){
        for (int i = 0; i < 10; i++) {
            ticket.sale();
        }
    }
}

...
A卖票后剩余11张票
A卖票后剩余10张票
...
C卖票后剩余2张票
C卖票后剩余1张票
A卖票后剩余9张票

synchronized

本质是加了个队列，是非公平锁。

public class Ticket {
    private int num = 30;

    public synchronized void sale(){
        if(num > 0){
            System.out.println(Thread.currentThread().getName() + "卖票后剩余" + --num + "张票" );
        }
    }
}

A卖票后剩余29张票
A卖票后剩余28张票
B卖票后剩余27张票
...
C卖票后剩余1张票
C卖票后剩余0张票

ReentrantLock

ReentrantLock参数为boolean，true表示是公平锁，默认为非公平锁。如果使用公平锁，从打印的日志可以看出，ABC基本是交替出现的。这样调度效率比较低。

import java.util.concurrent.locks.ReentrantLock;

public class Ticket {
    ReentrantLock lock = new ReentrantLock();
    private int num = 30;

    public void sale(){
        lock.lock();
        if(num > 0){
            System.out.println(Thread.currentThread().getName() + "卖票后剩余" + --num + "张票" );
        }
        lock.unlock();
    }
}

A卖票后剩余29张票
A卖票后剩余28张票
...
A卖票后剩余1张票
A卖票后剩余0张票

synchronized和lock的区别

  • synchronized是java内置的关键字；lock为一个java类
  • synchronized无法获取锁的状态；lock可以用以判断是否获取了锁
  • synchronized会自动释放锁；lock必须要手动释放锁，如果不是放锁会思索
  • synchronized可以重入，不可以中断，是非公平的；lock也是可重入锁，可以判断锁状态，可以是公平也可以是非公平。
  • synchronized适合锁少量代码的同步（代码块、方法、类名）；lock适合锁大量代码

虚假唤醒

使用if判断，唤醒后线程会从wait之后的代码开始运行，但是不会重新判断if条件，直接继续运行if代码块之后的代码，而如果使用while的话，也会从wait之后的代码运行，但是唤醒后会重新判断循环条件，如果不成立再执行while代码块之后的代码块，成立的话继续wait。

public class LockTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Producter producter = new Producter(clerk);
        Customer customer = new Customer(clerk);

        new Thread(producter,"生产者A").start();
        new Thread(customer,"消费者A").start();
        new Thread(producter,"生产者B").start();
        new Thread(customer,"消费者B").start();
    }
}

// 售货员
class Clerk {
    private int product = 0;

    // 进货
    public synchronized void add() {
        // 产品已满
        if (product >=1) {
            System.out.println(Thread.currentThread().getName() + ": " + "已满！");
            try {
                this.wait();
            } catch (InterruptedException e) {
            }
        }
        ++product;
        // 该线程从while中出来的时候，是满足条件的
        System.out.println(Thread.currentThread().getName() + ": " +"....................进货成功，剩下"+product);
        this.notifyAll();
    }

    // 卖货
    public synchronized void sale() {
        if (product <=0) {
            System.out.println(Thread.currentThread().getName() + ": " + "没有买到货");
            try {
                this.wait();
            } catch (InterruptedException e) {
            }
        }
        --product;
        System.out.println(Thread.currentThread().getName() + ":买到了货物，剩下 " + product);
        this.notifyAll();
    }
}

// 生产者
class Producter implements Runnable {
    private Clerk clerk;

    public Producter(Clerk clerk) {
        this.clerk = clerk;
    }

    // 进货
    @Override
    public void run() {
        for(int i = 0; i < 20; ++i) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
            }
            clerk.add();
        }
    }
}

// 消费者
class Customer implements Runnable {
    private Clerk clerk;
    public Customer(Clerk clerk) {
        this.clerk = clerk;
    }

    // 买货
    @Override
    public void run() {
        for(int i = 0; i < 20; ++i) {
            clerk.sale();
        }
    }
}

JUC生产者消费者

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

public class Clerk {
    private int product = 0;

    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    // 进货
    public void add() {
        lock.lock();
        try {
            while (product >= 1){
                System.out.println(Thread.currentThread().getName() + ": " + "已满！");
                condition.await();
            }
            System.out.println(Thread.currentThread().getName() + ": " +"....................进货成功，剩下"+product);
            ++product;
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    // 卖货
    public synchronized void sale() {
        lock.lock();
        try {
            while (product >= 1){
                System.out.println(Thread.currentThread().getName() + ": " + "已空！");
                condition.await();
            }
            System.out.println(Thread.currentThread().getName() + ":买到了货物，剩下 " + product);
            --product;
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        this.notifyAll();
    }
}
condition

condition可以精准的通知和唤醒线程，按照A->B->C的方式执行

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

public class Data {
    private int num = 1;

    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();


    public void print1() {
        lock.lock();
        try {
            while (num != 1) {
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName() + "正在执行");
            num = 2;
            condition2.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void print2() {
        lock.lock();
        try {
            while (num != 2) {
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName() + "正在执行");
            num = 3;
            condition3.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void print3() {
        lock.lock();
        try {
            while (num != 3) {
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName() + "正在执行");
            num = 1;
            condition1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

public static void main(String[] args) {
    Data data = new Data();
    new Thread(() -> {
        for (int i = 0; i < 10; i++) {
            data.print1();
        }
    }, "A").start();

    new Thread(() -> {
        for (int i = 0; i < 10; i++) {
            data.print2();
        }
    }, "B").start();

    new Thread(() -> {
        for (int i = 0; i < 10; i++) {
            data.print3();
        }
    }, "C").start();
}
拾薪
关注
Java并发编程类
路人而已的专栏
03-31 115
Java并发编程类
Java 并发编程
m0_61470267的博客
06-05 9509
java线程的回顾，java多线程出现的问题及解决方案，引入线程池的的原因，线程池的参数设置，以及引入ThreadLocal 线程变量，理解ThreadLocal的底层实现原理。
Java中的并发编程
梁恒嘉的博客（https://blog.crazymen.cn/）
10-20 766
记录Java并发编程的知识，包括并发编程的详细介绍，并发编程解决的问题，volatile关键字，各种锁机制，synchronized的底层原理，CAS机制，AQS机制，以及JUC里面常见方法
Java并发编程
qq_52163230的博客
01-21 1905
并发/并行 并发 是在某一个时间段内，依次做好几件事情，多个线程访问共享资源 单核cpu就不会出现问题 硬件cpu的功能逐渐强大，已经发展为多核，可以同时执行多个线程，就有可能多个线程同时访问同一个共享数据（秒杀抢购） 并发变成就是要让在多核，多线程下，也只能一次只有一个线程对共享资源访问 并行 多件事情在同一个时刻同事发生 多线程 多线程优点 多线程技术使程序的响应速度更快 ,可以在进行其它工作的同时一直处于活动状态,程序性能得到提升 性能提升的本质 就是榨取硬件的剩余价值(硬件利用率) 多线程带来的
java并发编程实战源码,java并发编程实战pdf,Java
09-10
《Java并发编程实战》是Java并发编程领域的一本经典著作，它深入浅出地介绍了如何在Java平台上进行高效的多线程编程。这本书的源码提供了丰富的示例，可以帮助读者更好地理解书中的理论知识并将其应用到实际项目中。...
java并发编程
01-20
Java并发编程是Java开发者必须掌握的关键技能之一，它涉及到如何在多线程环境中高效、安全地执行程序。并发编程能够充分利用多核处理器的计算能力，提高应用程序的响应速度和整体性能。《Java编程并发实战》这本书是...
java并发编程实践pdf笔记
12-15
Java并发编程实践是Java开发中不可或缺的一个领域，它涉及到如何高效、正确地处理多线程环境中的任务。这本书的读书笔记涵盖了多个关键知识点，旨在帮助读者深入理解Java并发编程的核心概念。 1. **线程和进程的...
Java并发编程实战华章专业开发者书库 (Tim Peierls 等 美Brian Goetz).pdf
04-09
《Java并发编程实战》是一本深入探讨Java平台并发编程的权威指南，由Tim Peierls等人与Brian Goetz合著，旨在帮助Java开发者理解和掌握在多线程环境中编写高效、安全的代码。这本书由拥有丰富经验的JDK并发大师及...
java并发编程实战源码-jcip-examples:java并发编程实战
05-25
《Java并发编程实战》是Java并发编程领域的一本经典之作，由Brian Goetz等作者撰写。这本书深入浅出地介绍了Java并发编程的各种概念和技术，帮助开发者理解和掌握如何在多线程环境中编写高效、安全的代码。jcip-...
Java并发编程（JUC）
weixin_43872993的博客
04-19 3858
1、Java并发编程——线程之间高效协作 2、了解JUC基本原理，了解各种锁的机制，避免死锁
使用Collections.synchronizedList对List的add方法加锁,使其add的时候线程安全
奔跑的菜鸡
08-02 2504
普通list是线程不安全的 List list = new ArrayList<>(); 在多线程的情况下,向list插入数据的时候,可能会造成数据丢失的情况.并且一个线程在遍历List,另一个线程修改List,会报ConcurrentModificationException(并发修改异常)错误. 原因入下图,多个线程进入add方法的时候,此时如果计算后不需要扩容,那么第一个元素是可以add进去的,但是之后的几个元素add的时候就会下表越界了,从而抛异常 用Collections.sync
Collections.synchronizedList使用方法
最新发布
weixin_45817985的博客
08-03 849
众所周知ArrayList是非线程安全的,在多线程的情况下,向list插入数据的时候,可能会造成数据丢失的情况.并且一个线程在遍历List,另一个线程修改List,会报ConcurrentModificationException(并发修改异常)错误.可以看出执行add()等方法的时候是加了synchronized关键字的,但是listIterator(),iterator()却没有加.所以在使用的时候需要加上synchronized.Collections.synchronizedList使用方法。
SynchronizedList的同步问题
hanzengbo2017的博客
09-02 3161
ArrayList是非线程安全的，在多线程中同时操作ArrayList会经常出现ConcurrentModificationException。为了解决同步问题，java提供了Collections的同步类：SynchronizedList、SynchronizedMap、SynchronizedSet等。以SynchronizedList为例，从字面意义上看，应该是线程安全的。在我们的代码中，我们
synchronized 不是可以保证有序性的吗?volatile的有序性?synchronized 不能够保证指令重排吗?
qq_42218187的博客
07-07 1451
怎么来定义顺序呢?《深入理解Java虚拟机第三版》有提到 Java程序中天然的有序性可以总结为一句话：如果在本线程内观察，所有操作都是天然有序的。如果在一个线程中观察另一个线程，所有操作都是无序的。前半句是指“线程内似表现为串行的语义”，后半句是指“指令重排”现象和“工作内存与主内存同步延迟”现象。 「synchronized」 的有序性是持有相同锁的两个同步块只能串行的进入，即被加锁的内容要按照顺序被多个线程执行，但是其内部的同步代码还是会发生重排序，使块与块之间有序可见。 「volatile」的有序性
java.util.Collections.synchronizedSet()方法实例
热门推荐
qq_17257809的博客
06-11 1万+
当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。 2种使用方法                      Synchronized method（）               synchronized(this){/
Java SynchronizedSet 线程不安全之坑
Jitwxs
03-01 3639
一、前言 一般而言，想要构造出线程安全的 Set，我们会使用 Collections.synchronizedSet 方法，如下所示。 Set<User> set = Collections.synchronizedSet(new HashSet<>()); 但这并不意味着，你可以安全的使用该集合的任何方法，如果没有仔细的了解过其实现的话，一不小心就会踩进坑中。 最近我在...
Java集合的使用
跟小白一起学编程！
10-17 380
集合的使用集合框架的概述数组在存储多个数据的特点数组在存储多个数据的缺点Java 集合可分为 Collection 和 Map 两种体系Collection接口Map接口Collection 接口的使用说明常用方法案例一案例二Iterator 迭代器说明Iterator 内部定义的方法案例Iterator 遍历集合的两种错误写法remove 方法的使用案例foreach 方式遍历集合元素说明案例小练习List 的使用说明ArrayList 源码分析（JDK7 & JDK8）JDK7 中的 Array
线程安全的容器
qq_42133677的博客
07-16 286
线程安全的容器 List ,Set SynchronizedList, SynchronizedSet 和名字一样为了保证线程安全，在List 和 Set的所有方法上加上了Synchronized关键字保证线程安全 优点：无论读取还是更新都保证时最新的数据 缺点：对于高并发读的业务性能不高 CopyOnWrite集合类 java.util.concurrent.CopyOnWriteArrayList java.util.concurrent.CopyOnWriteArraySet public boo
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值