Java多线程实例

Java多线程实例攻略

Java多线程是Java的一大特性，它可以使程序在运行时同时执行多个任务，提高了程序的效率。在本篇文章中，我们将讲述Java多线程的实例及使用方法，包含以下主题：

1. Java多线程基本概念
2. Java多线程创建方式
3. Java多线程共享变量及协调执行
4. 多线程应用——生产者和消费者模型

1. Java多线程基本概念

在Java中，一个程序可以有多个线程同时执行，每个线程都是独立的，有自己的栈空间和程序计数器，但是它们共享进程的内存空间。

Java多线程可以分为用户线程和守护线程两种类型。一般情况下，用户线程不会随着程序的结束而结束，而守护线程则会随着程序的结束而结束。

2. Java多线程创建方式

Java多线程可以通过两种方式创建，一种是继承Thread类，一种是使用Runnable接口。Thread类和Runnable接口都提供了run()方法用于定义线程要执行的任务。

示例一：通过继承Thread类创建线程

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

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

示例二：通过实现Runnable接口创建线程

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

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

3. Java多线程共享变量及协调执行

在多线程程序中，可能会出现多个线程同时访问同一个变量的情况，为了避免出现数据竞争等问题，我们需要采取相应的措施。

Java提供了synchronized关键字用于实现线程同步，synchronized可以用来修饰方法和代码块，确保同一时间只有一个线程可以访问这段代码。

同时，Java还提供了wait()、notify()和notifyAll()方法实现线程间的协作。wait()方法可以使线程等待某个条件满足的通知，而notify()和notifyAll()方法可以用于唤醒等待线程。

示例三：通过synchronized关键字实现线程同步

public class SynchronizedDemo {
    private int count = 0;

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

    public synchronized int getCount() {
        return count;
    }

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();

        for (int i = 0; i < 1000; i++) {
            new Thread(() -> synchronizedDemo.add()).start();
        }

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(synchronizedDemo.getCount()); // 打印1000
    }
}

示例四：通过wait()和notify()方法实现线程间协作

public class WaitNotifyDemo {
    private static boolean flag = false;
    private static Object lock = new Object();

    public static void main(String[] args) {
        Thread waitThread = new Thread(new WaitTask(), "WaitThread");
        Thread notifyThread = new Thread(new NotifyTask(), "NotifyThread");

        waitThread.start();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        notifyThread.start();
    }

    static class WaitTask implements Runnable {
        public void run() {
            synchronized (lock) {
                while (!flag) {
                    System.out.println(Thread.currentThread() + " begin waiting!");
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread() + " finish waiting!");
            }
        }
    }

    static class NotifyTask implements Runnable {
        public void run() {
            synchronized (lock) {
                flag = true;
                lock.notifyAll();
                System.out.println(Thread.currentThread() + " notify all!");
            }
        }
    }
}

4. 多线程应用——生产者和消费者模型

生产者和消费者模型是常见的多线程应用场景之一，它通常用于解决生产和消费的速度不匹配的问题。

在生产者和消费者模型中，通常会有一些共享的数据结构，例如队列，生产者会向队列中添加数据，而消费者会从队列中获取数据并消耗掉。当队列中没有数据时，消费者线程会进入等待状态，当队列中有数据时，生产者线程会通知消费者线程来消费。

示例五：生产者和消费者模型的实现

public class ProducerConsumerDemo {
    private Queue<Integer> queue = new LinkedList<>();
    private int maxSize = 10;

    public void produce() {
        while (true) {
            synchronized (queue) {
                while (queue.size() == maxSize) { // 队列已经满了
                    try {
                        System.out.println("Queue is full, Producer thread waiting for consumer to consume...");
                        queue.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                Random random = new Random();
                int num = random.nextInt(100);
                System.out.println("Producing: " + num);
                queue.add(num);
                queue.notifyAll();
            }
        }
    }

    public void consume() {
        while (true) {
            synchronized (queue) {
                while (queue.isEmpty()) { // 队列为空
                    try {
                        System.out.println("Queue is empty, Consumer thread waiting for producer to produce...");
                        queue.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                int num = queue.poll();
                System.out.println("Consuming: " + num);
                queue.notifyAll();
            }
        }
    }

    public static void main(String[] args) {
        ProducerConsumerDemo demo = new ProducerConsumerDemo();
        new Thread(() -> demo.produce()).start();
        new Thread(() -> demo.consume()).start();
    }
}

以上是Java多线程实例的完整攻略，希望能对您有所帮助。