重生之我在deepseek中学习java 第十天-Java-E先生的博客

Java学习指南-第十天：多线程编程

　　1.多线程简介

　　多线程是指在一个程序中同时运行多个线程，每个线程执行不同的任务。多线程可以提高程序的并发性和响应性。Java提供了丰富的API来支持多线程编程。

　　2.创建线程

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

　　继承Thread类：通过继承Thread类并重写run方法来创建线程。

　　实现Runnable接口：通过实现Runnable接口并将其传递给Thread对象来创建线程。

　　2.1继承Thread类

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + i);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();

        thread1.start();
        thread2.start();
    }
}

　　2.2实现Runnable接口

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + i);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new MyRunnable());
        Thread thread2 = new Thread(new MyRunnable());

        thread1.start();
        thread2.start();
    }
}

　　3.线程的生命周期

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

新建（New）：线程对象被创建，但尚未启动。
就绪（Runnable）：线程已经启动，等待CPU调度执行。
运行（Running）：线程正在执行run方法中的代码。
阻塞（Blocked）：线程因为某些原因（如等待资源）暂时停止执行。
终止（Terminated）：线程执行完毕或被强制终止。

　　4.线程同步

　　多线程环境下，多个线程可能会同时访问共享资源，导致数据不一致的问题。Java提供了synchronized关键字和Lock接口来实现线程同步。

　　4.1 synchronized关键字

　　synchronized关键字可以用于方法或代码块，确保同一时间只有一个线程可以执行该方法或代码块。

　　4.1.1同步方法

public class Counter {
    private int count = 0;

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

    public int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        System.out.println("Final Count: " + counter.getCount());
    }
}

　　4.1.2同步代码块

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

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

    public int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        System.out.println("Final Count: " + counter.getCount());
    }
}

　　4.2 Lock接口

　　Lock接口提供了比synchronized更灵活的锁机制。常用的实现类是ReentrantLock。

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 int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        System.out.println("Final Count: " + counter.getCount());
    }
}

　　5.线程间通信

　　线程间通信可以通过wait、notify和notifyAll方法实现。这些方法必须在synchronized块或方法中调用。

　　5.1 wait和notify

public class Message {
    private String message;
    private boolean empty = true;

    public synchronized String read() {
        while (empty) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        empty = true;
        notifyAll();
        return message;
    }

    public synchronized void write(String message) {
        while (!empty) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        empty = false;
        this.message = message;
        notifyAll();
    }
}

public class Main {
    public static void main(String[] args) {
        Message message = new Message();

        Thread writer = new Thread(() -> {
            String[] messages = {"Hello", "World", "Goodbye"};
            for (String msg : messages) {
                message.write(msg);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread reader = new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                String msg = message.read();
                System.out.println("Read: " + msg);
            }
        });

        writer.start();
        reader.start();
    }
}

　　6.今日任务

使用Thread类和Runnable接口分别创建两个线程，每个线程打印1到10的数字。
使用synchronized关键字实现一个线程安全的计数器。
使用wait和notify实现一个生产者-消费者模型。

　　7.示例代码

public class Main {
    public static void main(String[] args) {
        // 任务1：使用Thread类和Runnable接口创建线程
        Thread thread1 = new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        });

        thread1.start();
        thread2.start();

        // 任务2：使用synchronized实现线程安全的计数器
        Counter counter = new Counter();

        Thread thread3 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread thread4 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        thread3.start();
        thread4.start();

        try {
            thread3.join();
            thread4.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final Count: " + counter.getCount());

        // 任务3：使用wait和notify实现生产者-消费者模型
        Message message = new Message();

        Thread producer = new Thread(() -> {
            String[] messages = {"Message 1", "Message 2", "Message 3"};
            for (String msg : messages) {
                message.write(msg);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread consumer = new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                String msg = message.read();
                System.out.println("Consumed: " + msg);
            }
        });

        producer.start();
        consumer.start();
    }
}

class Counter {
    private int count = 0;

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

    public int getCount() {
        return count;
    }
}

class Message {
    private String message;
    private boolean empty = true;

    public synchronized String read() {
        while (empty) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        empty = true;
        notifyAll();
        return message;
    }

    public synchronized void write(String message) {
        while (!empty) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        empty = false;
        this.message = message;
        notifyAll();
    }
}

　　8.总结

　　今天的内容涵盖了多线程编程的基本概念和常用技术，包括线程的创建、线程同步、线程间通信等。多线程编程是Java编程中非常重要的一部分，务必熟练掌握。明天我们将深入学习Java的网络编程。

　　提示：多动手编写代码，尝试使用不同的多线程技术解决实际问题，理解多线程的工作原理和适用场景。

　　祝你学习愉快！