亚洲在线久爱草,狠狠天天香蕉网,天天搞日日干久草,伊人亚洲日本欧美

為了賬號安全，請及時綁定郵箱和手機立即綁定

Java高并發資料：新手入門教程

標簽：
Java 架構
概述

本文全面介绍了Java高并发资料，涵盖了高并发的基本概念、重要性以及Java中处理高并发的常用技术。文章详细解释了线程创建与启动、线程同步与互斥等关键知识点，并提供了丰富的代码示例和实战演练，帮助读者深入理解Java高并发资料。

Java高并发基础概念

什么是高并发

高并发是指在单位时间内，系统能够处理大量的请求。通常，高并发处理的系统需要能够支持大量用户同时访问，保证数据的一致性和系统的稳定性。在互联网领域，高并发处理能力是衡量一个系统性能的重要指标。

高并发的重要性

高并发对于现代互联网应用来说至关重要。随着互联网的发展，用户量和数据量都在不断增长，这使得系统需要处理更多的访问请求。高并发处理能力能够保证系统在面对大量请求时保持稳定运行，避免系统崩溃或性能下降。此外，高并发处理能力还能提高用户体验，减少等待时间，使系统更加高效和可靠。

Java中处理高并发的常用技术

在Java中处理高并发的方法有很多，主要包括线程、并发容器、并发工具类及并发编程模型等。

  • 线程：Java中的线程是并发编程的基本单位。通过创建和管理线程，可以实现任务的并行执行。
  • 并发容器：Java提供了多种并发容器，如ConcurrentHashMap、BlockingQueue等，可以在多线程环境下安全地进行数据操作。
  • 并发工具类：Java提供了同步工具类，如synchronized关键字、Lock接口、Condition接口等，用于控制访问资源的方式，确保线程安全。
  • 并发编程模型：如生产者-消费者模型、读写分离模型、资源池模型等，可以有效地管理和分配资源。

Java线程基础

线程的创建与启动

Java中的线程可以通过继承Thread类或实现Runnable接口来创建。创建线程后，需要调用start()方法来启动线程，而不是直接调用run()方法。

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程开始执行...");
    }

    public static void main(String[] args) {
        Thread thread = new MyThread();
        thread.start();  // 启动线程
    }
}
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("线程开始执行...");
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();  // 启动线程
    }
}

线程的状态和生命周期

Java线程的生命周期包括以下几个状态：

  • 新建状态（New）：新创建一个线程对象，但尚未启动。
  • 运行状态（Runnable）：线程已经被系统调度，开始执行任务。
  • 阻塞状态（Blocked）：线程等待获取锁或等待其他资源，暂时无法运行。
  • 等待状态（Waiting）：线程等待其他线程的特定操作完成。
  • 定时等待状态（Timed Waiting）：线程等待特定时间后唤醒。
  • 终止状态（Terminated）：线程执行完毕或因异常终止。

线程同步与互斥

线程同步确保多个线程访问共享资源时能够正确操作，避免数据不一致或错误。synchronized关键字和Lock接口是常用的同步机制。

public class Counter {
    private int count = 0;

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

    public synchronized void decrement() {
        count--;
    }
}
public class MyThread implements Runnable {
    private Counter counter;

    public MyThread(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
            counter.decrement();
        }
    }

    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread t1 = new Thread(new MyThread(counter));
        Thread t2 = new Thread(new MyThread(counter));
        t1.start();
        t2.start();
    }
}

Java并发容器的使用

List、Set和Map接口的并发实现类

Java并发容器提供了一些线程安全的集合实现类，如ConcurrentHashMap和CopyOnWriteArrayList。

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;

public class ConcurrentContainersExample {
    public static void main(String[] args) {
        ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();
        map.put("key1", "value1");
        map.put("key2", "value2");

        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        list.add("item1");
        list.add("item2");

        System.out.println(map);
        System.out.println(list);
    }
}

ConcurrentMap接口的实现类

ConcurrentHashMap是线程安全的HashMap实现，提供了高效的并发访问。下面是一个更详细的使用场景示例：

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapExample {
    public static void main(String[] args) {
        ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();
        map.put("key1", "value1");
        map.put("key2", "value2");

        map.putIfAbsent("key1", "value1");
        map.replace("key1", "value1", "newValue1");
        map.merge("key1", "newValue1", (oldValue, newValue) -> newValue);

        System.out.println(map);
    }
}

BlockingQueue接口的实现类

BlockingQueue接口提供了在多线程间传递数据的队列。常用的实现类有LinkedBlockingQueue和ArrayBlockingQueue。

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

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

        new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    queue.put(i);
                    System.out.println("生产了：" + i);
                    Thread.sleep(100);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    int value = queue.take();
                    System.out.println("消费了：" + value);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

使用CountDownLatch和CyclicBarrier的示例代码

CountDownLatch和CyclicBarrier是用于线程同步的工具类，下面分别给出详细的使用场景示例和解释。

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;

public class SynchronizationExample {
    public static void main(String[] args) {
        CountDownLatch countDownLatch = new CountDownLatch(2);
        CyclicBarrier cyclicBarrier = new CyclicBarrier(2);

        new Thread(() -> {
            System.out.println("线程1执行完毕...");
            countDownLatch.countDown();
            try {
                cyclicBarrier.await();
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(() -> {
            System.out.println("线程2执行完毕...");
            countDownLatch.countDown();
            try {
                cyclicBarrier.await();
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        }).start();

        try {
            countDownLatch.await();
            System.out.println("两个线程都执行完毕...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Java并发工具类详解

volatile关键字的作用

volatile关键字可以保证变量的可见性，即一个线程修改了volatile变量的值，其他线程可以立即看到这个变化。

public class VolatileExample {
    private volatile boolean flag = false;

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    public boolean getFlag() {
        return flag;
    }

    public static void main(String[] args) throws InterruptedException {
        VolatileExample example = new VolatileExample();
        new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            example.setFlag(true);
        }).start();

        while (!example.getFlag()) {
            // 等待flag变更为true
        }
        System.out.println("flag已更改");
    }
}

synchronized关键字详解

synchronized关键字可以锁定代码块或方法，确保同一时刻只有一个线程可以执行。

public class Counter {
    private int count = 0;

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

    public synchronized void decrement() {
        count--;
    }
}
public class MyThread implements Runnable {
    private Counter counter;

    public MyThread(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
            counter.decrement();
        }
    }

    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread t1 = new Thread(new MyThread(counter));
        Thread t2 = new Thread(new MyThread(counter));
        t1.start();
        t2.start();
    }
}

使用Lock接口实现更灵活的锁机制

Lock接口提供了更灵活的锁管理方式，支持非阻塞锁定和公平锁。

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

public class Counter {
    private int count = 0;
    private final Lock lock = new ReentrantLock();

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

    public void decrement() {
        lock.lock();
        try {
            count--;
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.decrement();
            }
        });
        t1.start();
        t2.start();
    }
}

Condition接口及其应用场景

Condition接口可以实现更复杂的线程协调和同步，如等待-通知模型。

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

public class ProducerConsumer {
    private final Lock lock = new ReentrantLock();
    private final Condition notEmpty = lock.newCondition();
    private final Condition notFull = lock.newCondition();
    private static final int MAX_SIZE = 10;
    private int count = 0;
    private int[] buffer = new int[MAX_SIZE];

    public void produce(int value) {
        lock.lock();
        try {
            while (count == MAX_SIZE) {
                System.out.println("缓冲区已满，等待消费者消费...");
                notFull.await();
            }
            buffer[count] = value;
            count++;
            notEmpty.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public int consume() {
        lock.lock();
        try {
            while (count == 0) {
                System.out.println("缓冲区为空，等待生产者生产...");
                notEmpty.await();
            }
            int value = buffer[count - 1];
            count--;
            notFull.signal();
            return value;
        } catch (InterruptedException e) {
            e.printStackTrace();
            return 0;
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        ProducerConsumer pc = new ProducerConsumer();
        Thread producer = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                pc.produce(i);
            }
        });
        Thread consumer = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("消费值：" + pc.consume());
            }
        });
        producer.start();
        consumer.start();
    }
}

Java并发编程模型

生产者消费者模式

生产者消费者模式是一种常见的并发模型，用于解决资源池的问题。生产者负责生成资源，消费者则消费这些资源。

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class ProducerConsumer {
    private static final int MAX_SIZE = 10;
    private final BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(MAX_SIZE);

    public void produce(int value) throws InterruptedException {
        queue.put(value);
    }

    public int consume() throws InterruptedException {
        return queue.take();
    }

    public static void main(String[] args) {
        ProducerConsumer pc = new ProducerConsumer();
        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    pc.produce(i);
                    System.out.println("生产了：" + i);
                    Thread.sleep(100);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread consumer = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    int value = pc.consume();
                    System.out.println("消费了：" + value);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        producer.start();
        consumer.start();
    }
}

读写分离模式

读写分离模式将读操作和写操作分开，读操作可以由多个线程同时执行，写操作则需要互斥执行。

import java.util.concurrent.locks.ReentrantLock;

public class ReaderWriter {
    private final ReentrantLock readLock = new ReentrantLock();
    private final ReentrantLock writeLock = new ReentrantLock();

    private int value = 0;

    public void write(int value) {
        writeLock.lock();
        try {
            this.value = value;
            System.out.println("写操作完成，当前值：" + value);
        } finally {
            writeLock.unlock();
        }
    }

    public int read() {
        readLock.lock();
        try {
            System.out.println("读操作完成，当前值：" + value);
            return value;
        } finally {
            readLock.unlock();
        }
    }

    public static void main(String[] args) {
        ReaderWriter rw = new ReaderWriter();
        Thread writer = new Thread(() -> {
            try {
                rw.write(10);
                Thread.sleep(2000);
                rw.write(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread reader1 = new Thread(rw::read);
        Thread reader2 = new Thread(rw::read);

        writer.start();
        reader1.start();
        reader2.start();
    }
}

资源池模式

资源池模式预先创建一批资源对象，供多个线程使用。这种方式可以减少资源创建和销毁的时间，提高系统性能。

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class ResourcePool {
    private static final int POOL_SIZE = 5;
    private final BlockingQueue<Integer> pool = new ArrayBlockingQueue<>(POOL_SIZE);

    public ResourcePool() {
        for (int i = 0; i < POOL_SIZE; i++) {
            pool.add(i);
        }
    }

    public int acquireResource() throws InterruptedException {
        return pool.take();
    }

    public void releaseResource(int resource) {
        pool.put(resource);
    }

    public static void main(String[] args) {
        ResourcePool pool = new ResourcePool();

        Thread[] threads = new Thread[5];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(() -> {
                try {
                    int resource = pool.acquireResource();
                    System.out.println("获取资源：" + resource);
                    Thread.sleep(2000);
                    pool.releaseResource(resource);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            threads[i].start();
        }
    }
}

实战演练：构建一个简单的高并发系统

分析需求

构建一个简单的高并发系统，可以模拟一个电商平台的商品库存管理。系统需要支持多个用户同时访问，保证商品库存的正确性。

设计架构

系统主要包括以下几个组件：

  • 库存管理模块：负责商品的增减操作。
  • 用户请求处理模块：处理用户的购买请求。
  • 数据库：存储商品信息和库存数量。

代码实现

import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;

public class InventoryManager {
    private final ReentrantLock lock = new ReentrantLock();
    private int stock = 100;

    public boolean purchase() {
        lock.lock();
        try {
            if (stock > 0) {
                stock--;
                System.out.println("购买成功，剩余库存：" + stock);
                return true;
            } else {
                System.out.println("库存不足，购买失败");
                return false;
            }
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        InventoryManager manager = new InventoryManager();

        Thread[] threads = new Thread[100];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(() -> {
                try {
                    if (manager.purchase()) {
                        TimeUnit.MILLISECONDS.sleep(50);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            threads[i].start();
        }
    }
}

测试与优化

在代码实现的基础上，可以通过以下方式进行测试与优化：

  • 性能测试：使用压力测试工具，如JMeter，测试系统的并发处理能力。
  • 资源利用率：监控系统资源的使用情况，确保资源合理分配。
  • 错误处理：增加错误处理逻辑，保证系统的鲁棒性。
  • 锁优化：使用更细粒度的锁，减少锁的持有时间。

通过这些步骤，可以确保系统在高并发环境下稳定运行，满足用户的需求。

點擊查看更多內容
為 TA 點贊

若覺得本文不錯，就分享一下吧！

評論

作者其他優質文章

正在加載中
  • 推薦
  • 評論
  • 收藏
  • 共同學習，寫下你的評論
感謝您的支持，我會繼續努力的～
掃碼打賞，你說多少就多少
贊賞金額會直接到老師賬戶
支付方式
打開微信掃一掃，即可進行掃碼打賞哦
今天注冊有機會得

100積分直接送

付費專欄免費學

大額優惠券免費領

立即參與 放棄機會
微信客服

購課補貼
聯系客服咨詢優惠詳情

 幫助反饋 APP下載

慕課網APP
您的移動學習伙伴

 公眾號

掃描二維碼
關注慕課網微信公眾號

舉報

0/150
提交
取消