实验五 Java多线程程序设计实验总结

Java多线程程序设计实验总结

引言

多线程是计算机科学中重要的概念，它允许同时执行多个任务，从而提高程序的效率和性能。在Java中，多线程被广泛应用于各种场景，例如并发编程、网络编程等。

本文将通过实验五的实践经验，介绍Java多线程程序设计的基本原理和常用技巧，并提供代码示例以加深理解。

多线程程序设计基础

多线程程序设计的基本原理是通过创建多个线程并行地执行任务。Java中实现多线程有两种方式：继承Thread类和实现Runnable接口。

继承Thread类

public class MyThread extends Thread {
    public void run() {
        // 线程执行的任务
    }
}

实现Runnable接口

public class MyRunnable implements Runnable {
    public void run() {
        // 线程执行的任务
    }
}

无论是继承Thread类还是实现Runnable接口，都需要重写run方法，在其中定义线程执行的任务。

创建和启动线程

创建线程的步骤是实例化线程对象，并调用start方法启动线程。

继承Thread类

MyThread thread = new MyThread();
thread.start();

实现Runnable接口

MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start();

线程同步与互斥

在多线程编程中，为了避免多个线程同时访问共享资源导致的数据不一致问题，需要使用线程同步和互斥机制。

synchronized关键字

synchronized关键字可以修饰方法或代码块，用于实现线程的互斥访问。

public synchronized void synchronizedMethod() {
    // 线程安全的代码
}

public void synchronizedBlock() {
    synchronized (this) {
        // 线程安全的代码
    }
}

ReentrantLock类

ReentrantLock类是Java提供的一个可重入锁实现，可以用于实现线程的互斥访问。

ReentrantLock lock = new ReentrantLock();
lock.lock();
try {
    // 线程安全的代码
} finally {
    lock.unlock();
}

线程间的通信

在多线程编程中，有时需要线程之间进行通信，以实现协同工作。

wait和notify方法

wait和notify方法是Java中用于线程通信的方法。

public synchronized void producer() {
    while (count >= CAPACITY) {
        wait(); // 等待条件满足
    }
    // 生产数据
    notifyAll(); // 唤醒等待的线程
}

public synchronized void consumer() {
    while (count <= 0) {
        wait(); // 等待条件满足
    }
    // 消费数据
    notifyAll(); // 唤醒等待的线程
}

实验示例

下面是一个生产者-消费者模型的示例代码：

public class ProducerConsumerExample {
    private static final int CAPACITY = 10;
    private static List<String> buffer = new ArrayList<>();

    public static void main(String[] args) {
        Thread producerThread = new Thread(new Producer());
        Thread consumerThread = new Thread(new Consumer());

        producerThread.start();
        consumerThread.start();
    }

    static class Producer implements Runnable {
        public void run() {
            while (true) {
                synchronized (buffer) {
                    while (buffer.size() >= CAPACITY) {
                        try {
                            buffer.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    String data = "data";
                    buffer.add(data);
                    System.out.println("Produced: " + data);
                    buffer.notifyAll();
                }
            }
        }
    }

    static class Consumer implements Runnable {
        public void run() {
            while (true) {
                synchronized (buffer) {
                    while (buffer.isEmpty()) {
                        try {
                            buffer.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    String data = buffer.remove(0);
                    System.out.println("Consumed: " + data);
                    buffer.notifyAll();
                }
            }
        }
    }
}

以上代码实现了一个简单的生产者-消费者