Java高并发资料：入门与初级教程-原创手记-慕课网

概述

Java高并发是指系统能够同时处理大量请求的能力，这对于保证用户体验至关重要。Java因其强大的并发处理能力和丰富的并发工具库，在高并发场景下表现出色。本文详细介绍了Java高并发的基础知识、常见问题及解决方案，并提供了丰富的示例代码。Java高并发资料涵盖了从基础概念到高级特性，帮助开发者更好地理解和应用高并发编程技术。

Java高并发基础知识

什么是高并发

高并发是指系统能够同时处理大量请求的能力。在分布式系统中，高并发意味着系统能够同时处理大量的客户端请求，保证每个请求都能得到及时响应。在互联网应用中，高并发是保证用户体验的重要因素。

高并发对Java的重要性

Java是一种广泛使用的编程语言，其强大的并发处理能力使得它在高并发场景下具有很高的价值。Java标准库提供了丰富的并发工具和机制，使得开发人员能够方便地实现高效、可靠的并发程序。此外，Java的跨平台特性也使得它在各种服务器和客户端环境中都能很好地工作。

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

常见的高并发问题包括线程安全问题、死锁、资源竞争等。为了解决这些问题，通常会采用同步机制、线程池、死锁检测等方法。例如，使用synchronized关键字来保证对共享资源的互斥访问，使用线程池来管理线程，避免频繁创建和销毁线程带来的开销。

线程安全问题及解决方案示例

public class SafeCounter {
    private int count;
    private final Object lock = new Object();

    public void increment() {
        synchronized (lock) {
            count++;
            System.out.println("Count incremented to " + count);
        }
    }
}

Java并发编程基础

线程与进程的区别

进程：是操作系统进行资源分配和调度的独立单位，拥有独立的地址空间和资源。
线程：是进程内的一个执行单元，共享进程的资源，但有自己的栈和程序计数器。

创建线程的方法

Java中主要有两种方法创建线程：

继承Thread类：

public class MyThread extends Thread {
public void run() {
    System.out.println("Hello from MyThread");
}

public static void main(String[] args) {
    MyThread thread = new MyThread();
    thread.start();
}
}

实现Runnable接口：

public class MyRunnable implements Runnable {
public void run() {
    System.out.println("Hello from MyRunnable");
}

public static void main(String[] args) {
    MyRunnable runnable = new MyRunnable();
    Thread thread = new Thread(runnable);
    thread.start();
}
}

线程的生命周期

线程在创建、调度和终止过程中会经历不同的状态，主要包括：

New：线程刚被创建，还没有调用start方法。
Runnable：线程已准备好运行，等待CPU时间片。
Running：线程正在执行状态。
Blocked：线程在等待锁或I/O操作。
Waiting：线程在等待其他线程的notify或notifyAll方法。
Timed Waiting：线程在等待一定时间后唤醒。
Terminated：线程结束。

同步与异步的概念及实现

同步：指多个线程访问共享资源时，需要通过某种机制来协调，确保同一时刻只有一个线程访问资源。
异步：指线程不必等待资源的操作完成即可继续执行其他任务，资源操作完成后通过回调等方式通知线程。

同步实现示例

public class SynchronizedExample {
    public void synchronizedMethod() {
        synchronized (this) {
            System.out.println("synchronizedMethod is running");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        SynchronizedExample example = new SynchronizedExample();
        new Thread(() -> example.synchronizedMethod()).start();
        new Thread(() -> example.synchronizedMethod()).start();
    }
}

异步实现示例

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class AsyncExample {
    ExecutorService executor = Executors.newFixedThreadPool(2);

    public void asyncMethod() {
        executor.submit(() -> {
            System.out.println("asyncMethod is running");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
    }

    public static void main(String[] args) {
        AsyncExample example = new AsyncExample();
        example.asyncMethod();
        example.asyncMethod();
    }
}

Java并发工具与机制

synchronized关键字

synchronized关键字用于实现方法级或代码块级的同步，确保同一时刻只有一个线程访问同步方法或代码块。

方法级同步

public synchronized void syncMethod() {
    // 这里是同步代码块
}

代码块级同步

public void syncBlock() {
    synchronized (this) {
        // 这里是同步代码块
    }
}

volatile关键字

volatile关键字用于确保变量的可见性，即一个线程对变量的修改，其他线程可以立即看到。

示例

public class VolatileExample {
    volatile boolean flag = false;

    public void changeFlag() {
        flag = true;
    }

    public static void main(String[] args) {
        VolatileExample example = new VolatileExample();
        new Thread(() -> {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            example.changeFlag();
        }).start();
        while (!example.flag) {
            System.out.println("Waiting for flag to be set to true");
        }
        System.out.println("flag is true");
    }
}

原子性操作类

java.util.concurrent.atomic包提供了许多原子性操作类，如AtomicInteger、AtomicLong等，这些类使得对变量的操作具有原子性，避免了多线程环境下的数据竞争。

示例

import java.util.concurrent.atomic.AtomicInteger;

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

    public void incrementCount() {
        for (int i = 0; i < 10000; i++) {
            count.incrementAndGet();
        }
    }

    public static void main(String[] args) {
        AtomicExample example = new AtomicExample();
        Thread thread1 = new Thread(example::incrementCount);
        Thread thread2 = new Thread(example::incrementCount);
        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final count: " + example.count.get());
    }
}

并发容器及使用场景

java.util.concurrent包提供了多种并发安全容器，如ConcurrentHashMap、CopyOnWriteArrayList等，这些容器在多线程环境下可以保证线程安全。

ConcurrentHashMap示例

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapExample {
    ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();

    public void putValue(String key, String value) {
        map.put(key, value);
    }

    public static void main(String[] args) {
        ConcurrentHashMapExample example = new ConcurrentHashMapExample();
        new Thread(() -> example.putValue("key1", "value1")).start();
        new Thread(() -> example.putValue("key2", "value2")).start();
        new Thread(() -> example.putValue("key3", "value3")).start();
    }
}

CopyOnWriteArrayList示例

import java.util.concurrent.CopyOnWriteArrayList;

public class CopyOnWriteArrayListExample {
    CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();

    public void addValue(String value) {
        list.add(value);
    }

    public static void main(String[] args) {
        CopyOnWriteArrayListExample example = new CopyOnWriteArrayListExample();
        new Thread(() -> example.addValue("value1")).start();
        new Thread(() -> example.addValue("value2")).start();
        new Thread(() -> example.addValue("value3")).start();
    }
}

Semaphore信号量

Semaphore是一种信号量机制，用于控制同时访问特定资源的线程数量。

示例

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    Semaphore semaphore = new Semaphore(2);

    public void accessResource() {
        try {
            semaphore.acquire();
            System.out.println("Accessing resource");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();
        }
    }

    public static void main(String[] args) {
        SemaphoreExample example = new SemaphoreExample();
        new Thread(example::accessResource).start();
        new Thread(example::accessResource).start();
        new Thread(example::accessResource).start();
    }
}

Java并发高级特性

CountDownLatch计数器

CountDownLatch允许一个或多个线程等待其他线程完成操作。

示例

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    static CountDownLatch latch = new CountDownLatch(2);

    public static void main(String[] args) {
        new Thread(() -> {
            System.out.println("Thread 1 started");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 1 finished");
            latch.countDown();
        }).start();

        new Thread(() -> {
            System.out.println("Thread 2 started");
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 2 finished");
            latch.countDown();
        }).start();

        try {
            latch.await();
            System.out.println("All threads finished");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

CyclicBarrier循环屏障

CyclicBarrier允许一组线程互相等待直到所有线程到达屏障点然后一次性继续执行。

示例

import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample {
    static CyclicBarrier barrier = new CyclicBarrier(2);

    public static void main(String[] args) {
        new Thread(() -> {
            System.out.println("Thread 1 started");
            try {
                Thread.sleep(1000);
                System.out.println("Thread 1 waiting at barrier");
                barrier.await();
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 1 proceeding");
        }).start();

        new Thread(() -> {
            System.out.println("Thread 2 started");
            try {
                Thread.sleep(1500);
                System.out.println("Thread 2 waiting at barrier");
                barrier.await();
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 2 proceeding");
        }).start();
    }
}

Phaser阶段器

Phaser是CyclicBarrier的扩展，允许多个阶段的等待和同步。

示例

import java.util.concurrent.Phase;

public class PhaserExample {
    static Phaser phaser = new Phaser(2);

    public static void main(String[] args) {
        new Thread(() -> {
            System.out.println("Thread 1 started");
            phaser.arriveAndAwaitAdvance();
            System.out.println("Thread 1 proceeding");
        }).start();

        new Thread(() -> {
            System.out.println("Thread 2 started");
            phaser.arriveAndAwaitAdvance();
            System.out.println("Thread 2 proceeding");
        }).start();
    }
}

CompletableFuture异步编程

CompletableFuture提供了多种异步编程模型，使得异步操作更加灵活和强大。

示例

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println("Running in background");
        });

        future.thenRun(() -> {
            System.out.println("Future completed");
        });
    }
}

实战案例分析

简单的银行转账场景

一个典型的银行转账场景中，需要确保两个账户之间的转账操作是原子性的。

示例

import java.util.concurrent.locks.ReentrantLock;

public class BankAccount {
    private int balance;
    private ReentrantLock lock = new ReentrantLock();

    public BankAccount(int balance) {
        this.balance = balance;
    }

    public void deposit(int amount) {
        lock.lock();
        try {
            balance += amount;
            System.out.println("Deposited " + amount + ", new balance is " + balance);
        } finally {
            lock.unlock();
        }
    }

    public void withdraw(int amount) {
        lock.lock();
        try {
            if (balance >= amount) {
                balance -= amount;
                System.out.println("Withdrew " + amount + ", new balance is " + balance);
            } else {
                System.out.println("Insufficient funds");
            }
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        BankAccount account = new BankAccount(1000);

        Thread depositThread = new Thread(() -> {
            account.deposit(500);
        });

        Thread withdrawThread = new Thread(() -> {
            account.withdraw(700);
        });

        depositThread.start();
        withdrawThread.start();
    }
}

多线程下载案例

一个简单的多线程下载文件的示例，可以大大提高下载速度。

示例

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MultiThreadDownload {
    public static void main(String[] args) throws IOException {
        URL url = new URL("http://example.com/largefile");
        HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();
        int fileSize = httpURLConnection.getContentLength();
        ExecutorService executor = Executors.newFixedThreadPool(4);

        for (int i = 0; i < 4; i++) {
            int start = i * (fileSize / 4);
            int end = (i == 3) ? fileSize : (i + 1) * (fileSize / 4);
            executor.submit(() -> downloadPart(url, start, end));
        }

        executor.shutdown();
        try {
            executor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private static void downloadPart(URL url, int start, int end) {
        try (InputStream in = url.openStream();
             FileOutputStream out = new FileOutputStream(new File("part" + start + ".bin"))) {
            byte[] buffer = new byte[1024];
            int read;
            while ((read = in.read(buffer)) != -1) {
                out.write(buffer, 0, read);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

使用线程池优化任务执行

使用线程池可以有效地管理和复用线程，避免频繁创建和销毁线程带来的开销。

示例

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(4);

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

        executor.shutdown();
        try {
            executor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

实际项目中遇到的高并发问题及解决方法

在实际项目中，经常遇到线程安全问题、死锁问题等。解决这些问题通常需要采用合理的并发控制机制，如使用synchronized关键字、线程池等。

示例

import java.util.concurrent.locks.ReentrantLock;

public class SharedResource {
    private int counter = 0;
    private ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            counter++;
            System.out.println("Counter incremented to " + counter);
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        SharedResource resource = new SharedResource();
        ExecutorService executor = Executors.newFixedThreadPool(4);

        for (int i = 0; i < 10; i++) {
            executor.submit(resource::increment);
        }

        executor.shutdown();
        try {
            executor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

常见问题与调试技巧

线程死锁问题及解决方法

线程死锁是指两个或多个线程互相等待对方持有的资源，导致所有线程都无法继续执行。解决方法包括避免嵌套锁、使用锁排序等。

示例

import java.util.concurrent.locks.ReentrantLock;

public class DeadlockExample {
    private static final ReentrantLock lock1 = new ReentrantLock();
    private static final ReentrantLock lock2 = new ReentrantLock();

    public static void main(String[] args) {
        new Thread(() -> {
            lock1.lock();
            System.out.println("Thread 1 locked lock1");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            lock2.lock();
            System.out.println("Thread 1 locked lock2");
        }).start();

        new Thread(() -> {
            lock2.lock();
            System.out.println("Thread 2 locked lock2");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            lock1.lock();
            System.out.println("Thread 2 locked lock1");
        }).start();
    }
}

线程安全问题及解决方法

线程安全问题通常发生在多个线程同时访问共享资源时。解决方法包括使用synchronized关键字、ReentrantLock等同步机制。

示例

import java.util.concurrent.locks.ReentrantLock;

public class ThreadSafetyExample {
    private int counter = 0;
    private ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            counter++;
            System.out.println("Counter incremented to " + counter);
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        ThreadSafetyExample example = new ThreadSafetyExample();
        ExecutorService executor = Executors.newFixedThreadPool(4);

        for (int i = 0; i < 10; i++) {
            executor.submit(example::increment);
        }

        executor.shutdown();
        try {
            executor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

JVM调优基础

通过调整JVM参数可以优化程序的性能，常用的参数有-Xmx和-Xms来设置堆内存大小，-XX:MaxPermSize来设置永久代大小等。

示例

public class JvmTuningExample {
    public static void main(String[] args) {
        // JVM参数调优示例
        // java -Xms128M -Xmx512M -XX:MaxPermSize=256M MainClass
    }
}

性能监控工具介绍

常用的性能监控工具包括JVisualVM、JConsole等，可以帮助开发者分析应用的性能瓶颈。

JVisualVM示例

打开JVisualVM工具。
连接到正在运行的Java应用程序。
查看CPU、内存、线程等信息。

JConsole示例

打开JConsole工具。
连接到正在运行的Java应用程序。
查看MBeans、线程、堆内存等信息。