Java多线程高并发，代码示例(一)

最新推荐文章于 2023-08-29 14:35:26 发布
最新推荐文章于 2023-08-29 14:35:26 发布
阅读量5.7k 收藏 17
点赞数 4
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25040155/article/details/87939591
版权
前言

项目主体源码可以从ConcurrenceBasics获得，喜欢的朋友可以点个star~。
参考文献在参考资料部分有介绍。

对某个对象加锁
/**
 * synchronized关键字
 * 对某个对象加锁
 */
public class T {
    private int count = 10;
    private Object o = new Object();
    public void m(){
        //任何线程要执行下面代码，必须先拿到o锁
        synchronized (o){
            count--;
            System.out.println(Thread.currentThread().getName() + " count = " + count);
        }
    }
}
对当前对象加锁(一)
/**
 * synchronized关键字
 * 对某个对象加锁
 */
public class T {
    private int count = 10;
    public void m(){
        //任何线程要执行下面的代码，必须先拿到this的锁
        synchronized (this){
            count--;
            System.out.println(Thread.currentThread().getName() + " count = " + count);
        }
    }
}
对当前对象加锁(二)
/**
 * synchronized关键字
 * 对某个对象加锁
 */
public class T {
    private int count = 10;
    //同等于在方法的代码执行要synchronized(this)
    public synchronized void m(){
        count--;
        System.out.println(Thread.currentThread().getName() + " count = " + count);
    }
}
对当前对象加锁(三)
/**
 * synchronized关键字
 * 对某个对象加锁
 */
public class T {
    private static int count = 10;
    //这里等同于synchronized(xxx.T.class)
    public synchronized static void m(){
        count--;
        System.out.println(Thread.currentThread().getName() + " count = " + count);
    }
    public static void ms(){
        synchronized (T.class){
            count--;
        }
    }
}
synchronized使用案例
/**
 * 实验结果:在run方法如果不加上synchronized，会产生线程抢占，
 * 如果加上就确保了线程运行的原子性，先执行的执行，后执行的等待。
 */
public class T implements Runnable {

    private int count = 10;

    @Override
    public /*synchronized*/ void run() {
        count--;
        System.out.println(Thread.currentThread().getName() + " count = " + count);
    }

    public static void main(String[] args) {
        T t = new T();
        for (int i = 0; i < 5; i++){
            new Thread(t, "Thread" + i).start();
        }
    }
}
在一个对象一面两个方法加不加synchronized修饰的影响
/**
 * 实验结果:此案例说明加synchronized修饰后的线程对象，
 * 和不加synchronized修饰，两者同时运行并不冲突。
 */
public class T {
    public synchronized void m1(){
        System.out.println(Thread.currentThread().getName() + " m1 start...");
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " m1 end...");
    }

    public void m2(){
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " m2...");
    }

    public static void main(String[] args) {
        T t = new T();
        //语法有点叼
        new Thread(()->t.m1(),"t1").start();
        new Thread(()->t.m2(),"t2").start();

        //和上面结果一样
        //new Thread(t::m1, "t1").start();
        //new Thread(t::m2, "t2").start();
    }
}
脏读以及解决方法
/**
 * 脏读
 * 实验结果:实验结果为0.0。
 * 解决方法:确保读写都加上synchronized，保证原子性。
 */
public class Account {
    String name;
    double balance;

    public synchronized void set(String name, double balance){
        this.name = name;
        //这里加上间隔时间的意义在于模拟线程被其他线程进行调用
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.balance = balance;
    }

    public /*synchronized*/ double getBalance(String name){
        return this.balance;
    }

    public static void main(String[] args) {
        Account account = new Account();
        new Thread(()->account.set("xipiker", 21.0)).start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(account.getBalance("xipiker"));

    }
}
synchronized获得的锁可重入
/**
 * 一个同步方法可以调用另一个同步方法，一个线程已经拥有某个对象的锁，
 * 再次申请的时候仍然会得到该兑现的锁。也就是说synchronized获得的
 * 锁是可重入的。
 */
public class T {
    synchronized void m1(){
        System.out.println("m1 start...");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        m2();
    }

    synchronized void m2(){
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("m2 start...");
    }

    public static void main(String[] args) {
        T t = new T();
        new Thread(()->t.m1(), "t1").start();
    }
}
子类调用父类的同步方法
/**
 * 子类调用父类的同步方法
 */
public class T {
    synchronized void m(){
        System.out.println("m start");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("m end");
    }

    public static void main(String[] args) {
        new TT().m();
    }
}

class TT extends T{
    synchronized void m(){
        System.out.println("child m start");
        super.m();
        System.out.println("child m end");
    }
}
程序运行出现异常，默认情况锁会被释放
/**
 * 程序在执行过程中，如果出现异常，默认情况下锁会被释放。
 * 所以，在并发处理过程中，有异常要多加小心，不然可能会发生不一致情况。
 * 比如，在一个web app处理过程中，多个servlet线程共同访问同一个资源，
 * 这时候如果异常处理不合适，在第一个线程中抛出异常，其他线程就会进入同步代码区，
 * 有可能会访问到异常产生时的数据。因此要非常小心的处理同步业务逻辑中的异常。
 * 实验结果:锁被释放了，原子性不存在了，第二个线程接着第一个线程继续执行。
 */
public class T {
    int count = 0;
    synchronized void m(){
        System.out.println(Thread.currentThread().getName() + " start...");
        while (true){
            count++;
            System.out.println(Thread.currentThread().getName() + " count = " + count);
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //这里我们模拟异常
            //此处抛出异常，锁将释放，要想不被释放，可以在这里进行catch，然后让循环继续
            if (count == 5){
                int i = 1/0;
            }
        }
    }

    public static void main(String[] args) {
        T t = new T();
        Runnable r = new Runnable() {
            @Override
            public void run() {
                t.m();
            }
        };

        new Thread(r, "t1").start();

        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(r, "t2").start();
    }
}
volatile使一个变量在多个线程间可见
/**
 * volatile关键字，使一个变量在多个线程间可见。
 * 例子: A B线程都用到一个变量，java默认是A线程中保留一份copy，这样如果B线程修改了该变量，则A线程未必知道
 * 使用volatile关键字，会让所有线程都会读到变量的赋值。
 *
 * 在下面代码中running是存在于堆内存的t对象中，当线程t1开始运行的时候，会把running值从内存中读到t1线程的工作区，
 * 在运行过程中直接使用这个copy，并不会每次都去读取堆内存，这样，当主线程修改running的值之后，t1线程感知不到，所以不会停止运行。
 * 使用volatile，将会强制所有线程都去堆内存中读取running的值。
 * volatile并不能保证多个线程共同修改running变量时所带来的不一致问题，也就是说volatile不能替代synchronized。
 */
public class T {
    volatile boolean running = true;
    void m(){
        System.out.println("m start...");
        while (running){

        }
        System.out.println("m end!");
    }

    public static void main(String[] args) {
        T t = new T();
        new Thread(t::m, "t1").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        t.running = false;
    }
}
volatile并不能保证原子性
/**
 * volatile并不能保证多个线程共同修改running变量时所带来的不一致问题，也就是说volatile不能代替synchronized。
 * 实验结果:多个线程间比如A线程执行中的count为100，B线程计算的A的count在加一为101，然后轮到A执行时他的count值时应该count结果为102，
 * 但是执行了为101，所以原本count的102值又被清回101。
 */
public class T {
    volatile int count = 5;
    void m(){
        for(int i = 0; i < 1000; i++)
            count++;
    }

    public static void main(String[] args) {
        T t = new T();
        List<Thread> threads = new ArrayList<Thread>();

        for (int i = 0; i < 10; i++){
            threads.add(new Thread(t::m, "Thread-" + i));
        }

        threads.forEach((o)->o.start());

        threads.forEach((o)->{
            try {
                o.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println(t.count);
    }
}
使用AtomXXX类，确保变量的原子性
/**
 * 确保变量的原子性，更加高效的方法可以使用AtomXXX类。
 * AtomXXX类本身方法都是原子性，但不能保证多个方法连续调用是原子性。
 */
public class T {
    AtomicInteger count = new AtomicInteger(0);
    void m(){
        for (int i = 0; i < 10000; i++)
            //if count.get() < 1000 ->这里如果执行那么就不在具有原子性了，
            // 因为可能会有线程执行到count.get() < 1000里面去，而又有的线程执行了下面的++操作。
            count.incrementAndGet(); //count++
    }

    public static void main(String[] args) {
        T t = new T();
        List<Thread> threadList = new ArrayList<Thread>();
        for (int i = 0; i < 10; i++){
            threadList.add(new Thread(t::m, "thread-" + i));
        }

        threadList.forEach((o)->o.start());

        threadList.forEach((o)->{
            try {
                o.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println(t.count);
    }
}
XIPIKER
关注
  • 4
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
多线程代码实例
06-04
生产消费管理系统，采用多线程实现。在程序整个运行过程中，存在1个控制线程、1个生产者线程、以及若干个消费者线程。使用POSIX标准的互斥量、条件变量等进行共享资源的保护。
多线程（十）多线程编程示例
gqg_guan的博客
11-23 154
多线程
多线程学习之多线程的案例
m0_62314761的博客
08-29 726
需求：有100份礼品,两人同时发送，当剩下的礼品小于10份的时候则不再送出。利用多线程模拟该过程并将线程的名字和礼物的剩余数量打印出来.
VC++多线程编程
weixin_33919941的博客
05-29 530
VC中多线程使用比较广泛而且实用,在网上看到的教程.感觉写的挺好. 一、问题的提出 编写一个耗时的单线程程序： 　　新建一个基于对话框的应用程序SingleThread，在主对话框IDD_SINGLETHREAD_DIALOG添加一个按钮，ID为IDC_SLEEP_SIX_SECOND，标题为 “延时6秒”，添加按钮的响应函数，代码如下： void CSingleThreadDl...
Java多线程并发执行demo代码实例
08-18
主要介绍了Java多线程并发执行demo代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java多线程高并发，代码示例(四)
XIPIKER的博客
03-05 2270
卖火车票问题(一) /** * 有N张火车票，每张票都有一个编号，同时有10个窗口对外售票。 * 分析下面的程序可能会产生哪些问题? * 重复销售?超量销售? * 问题:有可能卖重复，remove也不是原子性的。 */ public class TicketSeller1 { static List&amp;lt;String&amp;gt; tickets = new ArrayList&amp;lt...
多线程并发测试代码及解决方法
dfsafsd32323的博客
04-04 158
1.解决方法 Executors.newSingleThreadExecutor()取得的Executor实例有以下特性:任务顺序执行.比如：executor.submit(task1);executor.submit(task2);必须等task1执行完，task2才能执行。task1和task2会被放入一个队列里，由一个工作线程来处理。即：一共有2个线程(主线程、处理任务的工作线...
Java 高并发多线程编程系列案例代码
01-02
Java 高并发多线程编程系列案例代码 & 教程 & 面试题集锦! !! 包括但不限于线程安全性, atomic包下相关类、CAS原理、Unsafe类、synchronized关键字等的使用及注意事项,
Java多线程高并发，代码示例(三)
XIPIKER的博客
03-02 233
ThreadLocal线程的局部变量(一) /** * ThreadLocal线程的局部变量 */ public class ThreadLocal1 { volatile static Person p = new Person(); public static void main(String[] args) { new Thread(()-&amp;gt;{ ...
JAVA高质量并发详解,多线程并发深入讲解
最新发布
04-24
本书全面解析了Java并发编程的核心概念、原理和实践，帮助读者深入理解多线程并发编程的精髓，提升编程能力和系统性能。 书中首先介绍了并发编程的基础知识，包括线程的基本概念、线程的生命周期、线程安全等问题。...
多线程 高并发
06-27
在开发过程中自己编写的多线程并发程序组件源代码共享给大家，里面有测试的例子，提供给大家学习，希望大家多提宝贵意见~
多线程实例代码
11-09
多线程实例代码
Java多线程并发实战
06-22
Java多线程并发实战，值得推荐
多线程项目代码，实例
10-17
多线程项目代码，实例，delphi C C++.适用于初级中级开发者
java多线程并发编程例子
03-08
关于java.util.concurrent多线程核心包内各种线程资源的使用场景例子
深入理解Java多线程与并发编程
08-26
主要介绍了Java多线程与并发编程，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java常见面试题之多线程和高并发详解
08-26
主要给大家介绍了关于Java面试题之多线程和高并发的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用java具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
详解java解决分布式环境中高并发环境下数据插入重复问题
08-26
主要介绍了java解决并发数据重复问题 ，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
深入理解高并发编程-Java线程池核心技术
06-01
多线程可以理解为在同一个程序中能够同时运行多个不同的线程来执行不同的任务， 这些线程可以同时利用 CPU 的多个核心运行。多线程编程能够最大限度的利用 CPU 的资源。如果某一个线程的处理不需要占用 CPU 资源时...
帮我写一段java高并发多线程抢购代码
09-24
下面是一个简单的Java高并发多线程抢购代码示例： ```java import java.util.concurrent.atomic.AtomicInteger; public class GrabTicket implements Runnable { private static final AtomicInteger tickets = ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值