超级会员免费看
本文详细介绍了Java并发编程的基础，包括线程概念、创建线程的两种方式、线程生命周期，以及同步与锁的实现。重点讲解了`synchronized`关键字和`Lock`接口，还探讨了`java.util.concurrent`并发工具包，如Executor框架、Callable和Future、以及BlockingQueue。通过学习，读者将能够更好地理解和应用Java并发编程技术。
引言
在现代编程中，并发编程已经成为一个不可忽视的重要领域。通过并发编程，我们可以有效地利用多核处理器的能力，提高程序的执行效率和响应速度。在本篇文章中，我们将深入探讨Java的并发编程特性，学习多线程的基本概念和使用Java并发工具包来管理线程。
多线程基础
线程概念
线程是操作系统能够进行调度的最小单位。一个进程可以包含多个线程，这些线程共享进程的资源（如内存），但每个线程有自己的执行路径。
创建线程
在Java中，有两种创建线程的基本方法：继承Thread类和实现Runnable接口。
继承Thread类
通过继承Thread类，我们可以创建一个新的线程类并重写其run方法。
class MyThread extends Thread {
public void run() {
System.out.println("Thread is running");
}
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start();
}
}
实现Runnable接口
实现Runnable接口是另一种创建线程的方式，这种方式更加灵活，因为它允许我们的类继承其他类。
class MyRunnable implements Runnable {
public void run() {
System.out.println("Runnable is running");
}
public static void main(String[] args) {
Thread thread = new Thread(new MyRunnable());
thread.start();
}
}
线程生命周期
线程在其生命周期中有多个状态：新建（New）、可运行（Runnable）、运行中（Running）、阻塞（Blocked）、等待（Waiting）和终止（Terminated）。了解这些状态有助于更好地控制线程行为。
同步与锁
多线程编程中的一个重要问题是如何安全地访问共享资源。Java提供了多种机制来实现同步和线程安全。
synchronized关键字
synchronized关键字可以用于方法或代码块，确保同一时间只有一个线程可以执行被同步的方法或代码块。
class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
public int getCount() {
return count;
}
}
public class SynchronizedExample {
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.increment();
}
});
t1.start();
t2.start();
try {
t1.join();
t2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Final count: " + counter.getCount());
}
}
Lock接口
Lock接口提供了比synchronized关键字更广泛的锁操作。ReentrantLock是Lock接口的一个常用实现。
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class Counter {
private int count = 0;
private Lock lock = new ReentrantLock();
public void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock();
}
}
public int getCount() {
return count;
}
}
public class LockExample {
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.increment();
}
});
t1.start();
t2.start();
try {
t1.join();
t2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Final count: " + counter.getCount());
}
}
并发工具包（java.util.concurrent）
Java提供了丰富的并发工具包，包含许多实用的类和接口来简化并发编程。
Executor框架
Executor框架提供了更高层次的线程管理工具。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ExecutorExample {
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(2);
for (int i = 0; i < 5; i++) {
Runnable worker = new WorkerThread("" + i);
executor.execute(worker);
}
executor.shutdown();
while (!executor.isTerminated()) {
}
System.out.println("Finished all threads");
}
}
class WorkerThread implements Runnable {
private String command;
public WorkerThread(String s) {
this.command = s;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " Start. Command = " + command);
processCommand();
System.out.println(Thread.currentThread().getName() + " End.");
}
private void processCommand() {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
Callable和Future
Callable接口类似于Runnable，但它可以返回结果并且可以抛出异常。Future接口表示异步计算的结果。
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class CallableExample {
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(2);
Future<Integer> future = executor.submit(new Task());
try {
Integer result = future.get();
System.out.println("Result: " + result);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
executor.shutdown();
}
}
class Task implements Callable<Integer> {
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 1; i <= 10; i++) {
sum += i;
}
return sum;
}
}
BlockingQueue
BlockingQueue是一个线程安全的队列，可以用于实现生产者-消费者模型。
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class BlockingQueueExample {
public static void main(String[] args) {
BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(5);
Thread producer = new Thread(new Producer(queue));
Thread consumer = new Thread(new Consumer(queue));
producer.start();
consumer.start();
}
}
class Producer implements Runnable {
private BlockingQueue<Integer> queue;
public Producer(BlockingQueue<Integer> queue) {
this.queue = queue;
}
@Override
public void run() {
for (int i = 1; i <= 10; i++) {
try {
queue.put(i);
System.out.println("Produced: " + i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Consumer implements Runnable {
private BlockingQueue<Integer> queue;
public Consumer(BlockingQueue<Integer> queue) {
this.queue = queue;
}
@Override
public void run() {
try {
while (true) {
Integer value = queue.take();
System.out.println("Consumed: " + value);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
总结
在本篇文章中，我们详细探讨了Java的并发编程，包括线程的创建与管理、同步与锁机制，以及并发工具包的使用。掌握这些知识将使你能够编写高效、安全的并发程序。在接下来的文章中，我们将继续深入探索Java的其他高级特性和实际应用，希望你能继续关注并享受学习的过程！
如果你有任何问题或需要进一步的解释，请在评论区留言。我们将尽快回复。感谢阅读！
扫一扫
6909
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
