首页手记 JAVA高并发学习：从入门到初级实战

JAVA高并发学习：从入门到初级实战

标签：

Java 架构

概述

本文全面介绍了JAVA高并发学习的基础知识，包括高并发的特性和常见问题解决方案。文章还详细讲解了Java中常用的并发工具类及其应用场景，并通过示例代码进行了说明。此外，文章还探讨了线程的创建与管理、锁与并发控制等高级主题，并介绍了Executor框架和CompletableFuture异步编程，最后通过实战案例展示了如何模拟高并发场景以及如何进行高并发性能优化。

Java高并发基础知识

什么是高并发

高并发是指系统能够同时处理大量的请求，通常在短时间内有大量的用户访问或者数据处理。在互联网应用中，高并发是一个非常重要的特性，它直接关系到应用程序的响应速度和用户体验。高并发可以通过优化代码、使用合适的并发工具和设计合理的架构来实现。

高并发的特性主要包括：

响应时间短：用户等待的时间少，提高用户体验。
吞吐量大：系统能处理更多的请求，提高资源利用率。
资源利用效率高：合理的资源分配，减少资源浪费。

高并发常见问题及解决方案

在实现高并发的过程中，会遇到一些常见的问题，包括但不限于：

线程安全问题：多个线程访问共享资源时，可能导致数据不一致或程序崩溃。
死锁问题：多个线程互相等待对方释放资源，导致程序无法继续。
性能瓶颈：单个组件成为性能瓶颈，影响整个系统的性能。

解决方案包括：

使用锁机制：通过锁机制确保线程安全。
使用并发工具类：利用Java提供的并发工具类，如ConcurrentHashMap、BlockingQueue等。
优化代码：通过优化代码逻辑减少资源争抢。

Java中常用的并发工具类

Java提供了丰富的并发工具类，常见的有ConcurrentHashMap、CountDownLatch、CyclicBarrier、Semaphore等。

ConcurrentHashMap：提供线程安全的哈希表操作，适用于高并发的场景。
CountDownLatch：用于等待所有线程完成，常用于初始化操作。
CyclicBarrier：等待所有线程到达一个屏障点后继续执行，常用于多阶段任务。
Semaphore：用于限制同时访问资源的线程数量，常用于资源限制场景。

示例代码：

import java.util.concurrent.*;

public class ConcurrencyExample {
    public static void main(String[] args) {
        // 使用ConcurrentHashMap
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
        map.put("key1", 1);
        map.putIfAbsent("key2", 2);

        // 使用CountDownLatch
        CountDownLatch latch = new CountDownLatch(2);
        new Thread(() -> {
            try {
                Thread.sleep(1000);
                System.out.println("Task 1 completed");
                latch.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        new Thread(() -> {
            try {
                Thread.sleep(1500);
                System.out.println("Task 2 completed");
                latch.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        try {
            latch.await();
            System.out.println("All tasks completed");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 使用Semaphore
        Semaphore semaphore = new Semaphore(2);
        new Thread(() -> {
            try {
                semaphore.acquire();
                System.out.println("Thread 1 acquired semaphore");
                Thread.sleep(1000);
                System.out.println("Thread 1 released semaphore");
                semaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        new Thread(() -> {
            try {
                semaphore.acquire();
                System.out.println("Thread 2 acquired semaphore");
                Thread.sleep(1500);
                System.out.println("Thread 2 released semaphore");
                semaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

Java并发编程基础

线程的创建与管理

在Java中，可以使用Thread类或Runnable接口创建线程。线程的创建方法：

使用Thread类直接创建线程：
- 重写run方法实现线程任务。
- 调用start方法启动线程。
使用Runnable接口创建线程：
- 实现Runnable接口，重写run方法。
- 使用Thread类创建线程实例。

示例代码：

public class ThreadCreationExample {
    public static void main(String[] args) {
        // 使用Thread类创建线程
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("Thread1: " + i);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread1.start();

        // 使用Runnable接口创建线程
        Runnable runnable = () -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("Runnable: " + i);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        Thread thread2 = new Thread(runnable);
        thread2.start();
    }
}

线程之间的同步与互斥

线程之间的同步与互斥是解决多个线程访问共享资源时可能出现的数据不一致问题。Java提供了多种机制来实现同步和互斥。

使用synchronized关键字：
- 对象锁：synchronized代码块，使用对象作为锁。
- 类锁：synchronized代码块，使用this作为锁。

示例代码：

public class SynchronizedExample {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public static void main(String[] args) {
        SynchronizedExample example = new SynchronizedExample();
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Final count: " + example.count);
    }
}

使用ReentrantLock类：
- ReentrantLock提供了比synchronized更灵活的锁机制。
- 可以配置为公平锁或非公平锁。

示例代码：

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
    private int count = 0;
    private ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        ReentrantLockExample example = new ReentrantLockExample();
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Final count: " + example.count);
    }
}

Java并发高级主题

锁与并发控制

锁机制是Java并发控制的核心，常见的锁机制包括synchronized关键字和ReentrantLock类。

synchronized：
- 确保同一时间只有一个线程访问被synchronized修饰的代码块或方法。
- 简单易用，但灵活性较差。
ReentrantLock：
- 提供更多的灵活性，例如可配置为公平锁或非公平锁。
- 支持尝试锁和定时锁。

示例代码：

public class ReentrantLockExampleAdvanced {
    private int count = 0;
    private ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        ReentrantLockExampleAdvanced example = new ReentrantLockExampleAdvanced();
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Final count: " + example.count);
    }
}

原子性与可见性

原子性与可见性是保证并发操作正确性的基础。

原子性：
- 操作是不可分割的，要么全部执行，要么全部不执行。
- 可以使用synchronized关键字或Atomic类保证原子性。
可见性：
- 确保一个线程对共享变量的修改能够被其他线程及时看到。
- 可以使用volatile关键字或synchronized机制实现。

示例代码：

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicExample {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet();
    }

    public static void main(String[] args) {
        AtomicExample example = new AtomicExample();
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Final count: " + example.count.get());
    }
}

Java并发库介绍

使用Executor框架

Executor框架提供了一种标准的方式来创建和管理线程，避免了直接使用Thread带来的复杂性和混乱。

ThreadPoolExecutor：
- 创建线程池，管理线程生命周期。
- 提供了各种线程池配置选项，如核心线程数、最大线程数、队列容量等。

示例代码：

import java.util.concurrent.*;

public class ThreadPoolExample {
    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                2, // 核心线程数
                4, // 最大线程数
                1000, // 空闲线程存活时间
                TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<>(10) // 队列容量
        );

        for (int i = 0; i < 10; i++) {
            int finalI = i;
            executor.execute(() -> {
                System.out.println("Task " + finalI + " is running on " + Thread.currentThread().getName());
            });
        }

        executor.shutdown();
    }
}

// 核心线程数：线程池中初始的线程数量。
// 最大线程数：线程池中允许的最大线程数量。
// 空闲线程存活时间：当线程空闲时，等待新任务的时间。
// 队列容量：任务队列的最大容量。

CompletableFuture异步编程

CompletableFuture是一种强大的异步编程工具，它提供了丰富的组合和转换方法，简化异步代码的编写。

异步提交任务：
- 使用supplyAsync或runAsync方法提交异步任务。
组合和转换：
- 使用thenApply、thenRun、thenAccept等方法组合多个异步操作。

示例代码：

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture.supplyAsync(() -> {
            System.out.println("Async task is running on " + Thread.currentThread().getName());
            return "Hello, CompletableFuture!";
        }).thenApply(result -> {
            System.out.println("Task result: " + result);
            return result.toUpperCase();
        }).thenAccept(result -> {
            System.out.println("Final result: " + result);
        }).join();
    }
}

高并发编程模式

生产者消费者模式

生产者消费者模式是一种经典的设计模式，用于解决生产者和消费者之间的同步问题。

使用BlockingQueue：
- 生产者将数据放入队列，消费者从队列中取出数据。
- BlockingQueue提供了线程安全的队列操作。

示例代码：

import java.util.concurrent.*;

public class ProducerConsumerExample {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(10);

        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    queue.put(i);
                    System.out.println("Producer produced: " + i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread consumer = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    int result = queue.take();
                    System.out.println("Consumer consumed: " + result);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        producer.start();
        consumer.start();

        try {
            producer.join();
            consumer.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

读写分离模式

读写分离模式是一种常见的数据库高可用方案，通过将读和写操作分离到不同的数据库实例，提高系统的并发能力和可用性。

读操作：
- 从只读副本读取数据，降低主库压力。
写操作：
- 写入主库，确保数据一致性。

示例代码：

import java.util.concurrent.CopyOnWriteArrayList;

public class ReadWriteSeparationExample {
    private CopyOnWriteArrayList<Integer> data = new CopyOnWriteArrayList<>();

    public void write(int value) {
        data.add(value);
        System.out.println("Write: " + value);
    }

    public void read() {
        for (int value : data) {
            System.out.println("Read: " + value);
        }
    }

    public static void main(String[] args) {
        ReadWriteSeparationExample example = new ReadWriteSeparationExample();

        Thread writer = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                example.write(i);
            }
        });

        Thread reader = new Thread(() -> {
            example.read();
        });

        writer.start();
        reader.start();

        try {
            writer.join();
            reader.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

实战案例

实战模拟高并发场景

模拟高并发场景可以更好地理解并发编程中的问题和解决方案。下面的示例模拟了一个简单的高并发请求场景，使用线程池执行大量并发请求。

创建线程池：
- 使用ThreadPoolExecutor创建线程池。
提交任务：
- 提交大量任务到线程池。

示例代码：

import java.util.concurrent.*;

public class HighConcurrencySimulation {
    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                2, // 核心线程数
                4, // 最大线程数
                1000, // 空闲线程存活时间
                TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<>(100) // 队列容量
        );

        for (int i = 0; i < 100; i++) {
            executor.execute(() -> {
                System.out.println("Task " + Thread.currentThread().getName() + " is running");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        executor.shutdown();
    }
}

优化高并发性能

优化高并发性能可以从多个方面入手，包括减少锁竞争、提高缓存命中率、使用合适的数据结构等。

减少锁竞争：
- 使用细粒度锁或无锁数据结构，减少锁的竞争。
提高缓存命中率：
- 使用缓存机制，减少对数据库等慢资源的访问。

示例代码：

import java.util.concurrent.*;

public class OptimizationExample {
    private ConcurrentHashMap<Integer, Integer> cache = new ConcurrentHashMap<>();

    public int get(int key) {
        if (cache.containsKey(key)) {
            System.out.println("Cache hit: " + key);
            return cache.get(key);
        } else {
            System.out.println("Cache miss: " + key);
            int result = calculate(key);
            cache.put(key, result);
            return result;
        }
    }

    private int calculate(int key) {
        // 模拟计算过程
        return key * 2;
    }

    public static void main(String[] args) {
        OptimizationExample example = new OptimizationExample();

        for (int i = 0; i < 10; i++) {
            int result = example.get(i);
            System.out.println("Result: " + result);
        }
    }
}

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

茅侃侃

手记
篇

粉丝

8

获赞与收藏

19

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19187 313

Java 并发原理入门教程

26个小节 38860 566

Java 入门教程

50个小节 340953 3155

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

JAVA高并发学习：从入门到初级实战

Java高并发基础知识

什么是高并发

高并发常见问题及解决方案

Java中常用的并发工具类

Java并发编程基础

线程的创建与管理

线程之间的同步与互斥

Java并发高级主题

锁与并发控制

原子性与可见性

Java并发库介绍

使用Executor框架

CompletableFuture异步编程

高并发编程模式

生产者消费者模式

读写分离模式

实战案例

实战模拟高并发场景

优化高并发性能

阅读免费教程