Java 多线程与高并发

简介: Java 多线程与高并发
1:volatile
  • 保证线程可见性

当多个线程访问同一个共享资源时,线程会拷贝资源的副本到自己的工作内存。这样如果某个线程对这个资源进行写操作,其他线程不会马上知道。当对这个资源加volatile关键字,其他线程就会随时监听,更新新的值。
如下例子,不加volatile关键字,线程不会停止,加volatile关键字后会及时重新更新副本stop的值,线程停止。

package com.nobody.thread;
/**
*    不加volatile,输出:
*    main start...
*    thread start...
*    change stop=true
*    
*   加volatile,输出:
*    main start...
*    thread start...
*    thread stop...
*    change stop=true
* @author Μr.ηobοdy
*
* @date 2020-04-19
*
*/
public class VolatileDemo {

   private /* volatile */ static boolean stop = false;

   public static void main(String[] args) {
       
       Thread t = new Thread(() -> {
           System.out.println("thread start...");
           while (!stop) {
               
           }
           System.out.println("thread stop...");
       });
       
       System.out.println("main start...");
       
       t.start();
       
       try {
           Thread.sleep(1000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       
       stop = true;
       System.out.println("change stop=" + stop);
   }

}

在这里插入图片描述

  • 禁止指令重排序

JIT(即时编译器just-in-time compiler) 是一种提高程序运行效率的方法,会将指令重排序。例如实例化一个对象,一般可分为3步骤,第一分配内存空间,第二初始化变量等,第三将引用地址赋值给引用对象。指令重排序可将顺序改为132。这样引用对象可能就拿到一个未初始化的对象,导致出错。

package com.nobody.thread;

/**
 *  单例模式(懒汉式) 
 *  懒汉式必须加volatile
 * 
 * @author Μr.ηobοdy
 *
 * @date 2020-04-19
 *
 */
public class Singleton {

    private /* vovalite */ static Singleton INSTANCE;

    private String name;

    private Singleton(String name) {
        this.name = name;
    }

    public static Singleton getInstance() {
        if (null == INSTANCE) {
            synchronized (Singleton.class) {
                if (null == INSTANCE) {
                    // 可能会出现指令重排序,即未进行成员变量name的初始化就退出了,
                    // 这样别人就会拿到未初始化(name=null)的Singleton对象
                    INSTANCE = new Singleton("hh");
                }
            }
        }
        return INSTANCE;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}
  • 不保证原子性
package com.nobody.thread;

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

/**
 * volatile不保证原子性,最终结果一般小于10000
 * 
 * 若要保证原子性,直接将doCount方法加synchronized关键字即可,而volatile可有可无
 * 
 * @author Μr.ηobοdy
 *
 * @date 2020-04-19
 *
 */
public class VolatileDemo1 {

    private volatile static int count = 0;

    private /*synchronized*/ void doCount() {
        for (int i = 0; i < 1000; i++) {
            count++;
        }
    }

    public static void main(String[] args) {

        VolatileDemo1 v = new VolatileDemo1();

        // 启动10个线程
        List<Thread> threads = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            threads.add(new Thread(v::doCount, "thread-" + i));
        }
        threads.forEach(t -> t.start());

        // 等待10个线程执行完
        threads.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        System.out.println("count=" + count);
    }

}
2:CAS(Compare And Set 无锁优化 自旋锁)

设置新值之前会先将旧的值与期望值比较,如果相等才set,不然就重试或者失败。这是有CPU原语支持的。

package com.nobody.thread;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * CAS AtomicInteger保证原子性,最终结果一定等于10000
 * 
 * 
 * @author Μr.ηobοdy
 *
 * @date 2020-04-19
 *
 */
public class AtomicIntegerDemo {

    private static AtomicInteger count = new AtomicInteger(0);

    private void doCount() {
        for (int i = 0; i < 1000; i++) {
            count.incrementAndGet();
        }
    }

    public static void main(String[] args) {

        AtomicIntegerDemo v = new AtomicIntegerDemo();

        // 启动10个线程
        List<Thread> threads = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            threads.add(new Thread(v::doCount, "thread-" + i));
        }
        threads.forEach(t -> t.start());

        // 等待10个线程执行完
        threads.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        System.out.println("count=" + count);
    }

}

不过这种会出现ABA问题,即由值A先变成值B,然后又变回A值,最后旧值与期望值比较还是相等。可用版本号解决这个问题。

3:LongAdder

采用分段锁思想,假如有1000个线程对同一个共享变量进行操作(例如自增),此处假设分为4小组,250个线程为1组,组内进行自增操作,这样分组能减少锁的概率,最后将每个小组进行求总和处理。其实分段锁组内还是CAS原理。一般在线程数高时,效率比synchronized和AtomicLong高。

package com.nobody.thread;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.LongAdder;

/**
 * LongAdder,AtomicLong,synchronized多线程时效率比较
 * 模拟1000个线程对一个等于0的值进行自增操作,每个线程自增10000
 * 
 * 输出结果:
 * longAdderCount:10000000, time:227
 * atomicLongCount:10000000, time:395
 * synchronizedCount:10000000, time:909
 * 
 * @author Μr.ηobοdy
 *
 * @date 2020-04-20
 *
 */
public class LongAdderDemo {

    private static LongAdder longAdderCount = new LongAdder();
    private static AtomicLong atomicLongCount = new AtomicLong(0L);
    private static long synchronizedCount = 0L;

    public static void main(String[] args) {

        // LongAdder测试
        List<Thread> longAdderThreads = new ArrayList<>(1000);
        for (int i = 1; i <= 1000; i++) {
            longAdderThreads.add(new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    longAdderCount.increment();
                }
            }));
        }
        long start = System.currentTimeMillis();
        longAdderThreads.forEach(t -> t.start());
        // 等待1000个线程执行完
        longAdderThreads.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        long end = System.currentTimeMillis();

        // AtomicLong测试
        List<Thread> atomicLongThreads = new ArrayList<>(1000);
        for (int i = 1; i <= 1000; i++) {
            atomicLongThreads.add(new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    atomicLongCount.incrementAndGet();
                }
            }));
        }
        long start1 = System.currentTimeMillis();
        atomicLongThreads.forEach(t -> t.start());
        // 等待1000个线程执行完
        atomicLongThreads.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        long end1 = System.currentTimeMillis();
        
        
     // AtomicLong测试
        List<Thread> synchronizedThreads = new ArrayList<>(1000);
        Object o = new Object();
        for (int i = 1; i <= 1000; i++) {
            synchronizedThreads.add(new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    synchronized (o) {
                        synchronizedCount++;
                    }
                }
            }));
        }
        long start2 = System.currentTimeMillis();
        synchronizedThreads.forEach(t -> t.start());
        // 等待1000个线程执行完
        synchronizedThreads.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        long end2 = System.currentTimeMillis();

        System.out.println("longAdderCount:" + longAdderCount + ", time:" + (end - start));
        System.out.println("atomicLongCount:" + atomicLongCount + ", time:" + (end1 - start1));
        System.out.println("synchronizedCount:" + synchronizedCount + ", time:" + (end2 - start2));
    }

}
相关文章
|
4天前
|
安全 Java 开发者
深入解读JAVA多线程:wait()、notify()、notifyAll()的奥秘
在Java多线程编程中,`wait()`、`notify()`和`notifyAll()`方法是实现线程间通信和同步的关键机制。这些方法定义在`java.lang.Object`类中,每个Java对象都可以作为线程间通信的媒介。本文将详细解析这三个方法的使用方法和最佳实践,帮助开发者更高效地进行多线程编程。 示例代码展示了如何在同步方法中使用这些方法,确保线程安全和高效的通信。
23 9
|
7天前
|
存储 安全 Java
Java多线程编程的艺术:从基础到实践####
本文深入探讨了Java多线程编程的核心概念、应用场景及其实现方式,旨在帮助开发者理解并掌握多线程编程的基本技能。文章首先概述了多线程的重要性和常见挑战,随后详细介绍了Java中创建和管理线程的两种主要方式:继承Thread类与实现Runnable接口。通过实例代码,本文展示了如何正确启动、运行及同步线程,以及如何处理线程间的通信与协作问题。最后,文章总结了多线程编程的最佳实践,为读者在实际项目中应用多线程技术提供了宝贵的参考。 ####
|
4天前
|
监控 安全 Java
Java中的多线程编程:从入门到实践####
本文将深入浅出地探讨Java多线程编程的核心概念、应用场景及实践技巧。不同于传统的摘要形式,本文将以一个简短的代码示例作为开篇,直接展示多线程的魅力,随后再详细解析其背后的原理与实现方式,旨在帮助读者快速理解并掌握Java多线程编程的基本技能。 ```java // 简单的多线程示例:创建两个线程,分别打印不同的消息 public class SimpleMultithreading { public static void main(String[] args) { Thread thread1 = new Thread(() -> System.out.prin
|
7天前
|
Java
JAVA多线程通信:为何wait()与notify()如此重要?
在Java多线程编程中,`wait()` 和 `notify()/notifyAll()` 方法是实现线程间通信的核心机制。它们通过基于锁的方式,使线程在条件不满足时进入休眠状态,并在条件满足时被唤醒,从而确保数据一致性和同步。相比其他通信方式,如忙等待,这些方法更高效灵活。 示例代码展示了如何在生产者-消费者模型中使用这些方法实现线程间的协调和同步。
21 3
|
6天前
|
安全 Java
Java多线程集合类
本文介绍了Java中线程安全的问题及解决方案。通过示例代码展示了使用`CopyOnWriteArrayList`、`CopyOnWriteArraySet`和`ConcurrentHashMap`来解决多线程环境下集合操作的线程安全问题。这些类通过不同的机制确保了线程安全,提高了并发性能。
|
7天前
|
Java
java小知识—进程和线程
进程 进程是程序的一次执行过程,是系统运行的基本单位,因此进程是动态的。系统运行一个程序即是一个进程从创建,运行到消亡的过程。简单来说,一个进程就是一个执行中的程序,它在计算机中一个指令接着一个指令地执行着,同时,每个进程还占有某些系统资源如CPU时间,内存空间,文件,文件,输入输出设备的使用权等等。换句话说,当程序在执行时,将会被操作系统载入内存中。 线程 线程,与进程相似,但线程是一个比进程更小的执行单位。一个进程在其执行的过程中产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源,所以系统在产生一个线程,或是在各个线程之间做切换工作时,负担要比
17 1
|
7天前
|
Java UED
Java中的多线程编程基础与实践
【10月更文挑战第35天】在Java的世界中,多线程是提升应用性能和响应性的利器。本文将深入浅出地介绍如何在Java中创建和管理线程,以及如何利用同步机制确保数据一致性。我们将从简单的“Hello, World!”线程示例出发,逐步探索线程池的高效使用,并讨论常见的多线程问题。无论你是Java新手还是希望深化理解,这篇文章都将为你打开多线程的大门。
|
1月前
|
存储 消息中间件 资源调度
C++ 多线程之初识多线程
这篇文章介绍了C++多线程的基本概念,包括进程和线程的定义、并发的实现方式,以及如何在C++中创建和管理线程,包括使用`std::thread`库、线程的join和detach方法,并通过示例代码展示了如何创建和使用多线程。
41 1
C++ 多线程之初识多线程
|
22天前
|
Java 开发者
在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口
【10月更文挑战第20天】在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口。本文揭示了这两种方式的微妙差异和潜在陷阱,帮助你更好地理解和选择适合项目需求的线程创建方式。
16 3
|
22天前
|
Java 开发者
在Java多线程编程中,选择合适的线程创建方法至关重要
【10月更文挑战第20天】在Java多线程编程中,选择合适的线程创建方法至关重要。本文通过案例分析,探讨了继承Thread类和实现Runnable接口两种方法的优缺点及适用场景,帮助开发者做出明智的选择。
15 2

热门文章

最新文章

  • 1
    高并发场景下,到底先更新缓存还是先更新数据库?
    64
  • 2
    Java面试题:解释Java NIO与BIO的区别,以及NIO的优势和应用场景。如何在高并发应用中实现NIO?
    74
  • 3
    Java面试题:设计一个线程安全的单例模式,并解释其内存占用和垃圾回收机制;使用生产者消费者模式实现一个并发安全的队列;设计一个支持高并发的分布式锁
    68
  • 4
    Java面试题:如何实现一个线程安全的单例模式,并确保其在高并发环境下的内存管理效率?如何使用CyclicBarrier来实现一个多阶段的数据处理任务,确保所有阶段的数据一致性?
    62
  • 5
    Java面试题:结合建造者模式与内存优化,设计一个可扩展的高性能对象创建框架?利用多线程工具类与并发框架,实现一个高并发的分布式任务调度系统?设计一个高性能的实时事件通知系统
    55
  • 6
    Java面试题:假设你正在开发一个Java后端服务,该服务需要处理高并发的用户请求,并且对内存使用效率有严格的要求,在多线程环境下,如何确保共享资源的线程安全?
    69
  • 7
    在Java中实现高并发的数据访问控制
    42
  • 8
    使用Java构建一个高并发的网络服务
    29
  • 9
    微服务06----Eureka注册中心,微服务的两大服务,订单服务和用户服务,订单服务需要远程调用我们的用,户服务,消费者,如果环境改变,硬编码问题就会随之产生,为了应对高并发,我们可能会部署成一个集
    37
  • 10
    如何设计一个秒杀系统,(高并发高可用分布式集群)
    129