Java多线程深入理解

Java多线程深入理解攻略

在进行深入理解Java多线程的过程中，需要掌握以下几点：

1. 线程的创建和启动

Java中线程的创建有两种方式，一种是继承Thread类，一种是实现Runnable接口。其中，实现Runnable接口的方式更加灵活，因为一个类可以实现多个接口。

// 继承Thread类
class MyThread extends Thread {
    public void run() {
        // 线程执行的代码
        System.out.println("MyThread is running.");
    }
}

// 实现Runnable接口
class MyRunnable implements Runnable {
    public void run() {
        // 线程执行的代码
        System.out.println("MyRunnable is running.");
    }
}

// 测试创建并启动线程
public static void main(String[] args) {
    MyThread t1 = new MyThread();
    t1.start(); // 启动线程

    MyRunnable r1 = new MyRunnable();
    Thread t2 = new Thread(r1);
    t2.start(); // 启动线程
}

2. 线程同步

在多线程环境下，共享资源容易造成冲突，而使用同步机制可以避免这个问题。Java提供了两种同步机制：synchronized方法和synchronized代码块。

class Counter {
    private int count;

    // 通过方法同步
    public synchronized void increment() {
        count++;
    }

    // 通过代码块同步
    public void decrement() {
        synchronized (this) {
            count--;
        }
    }

    public int getCount() {
        return count;
    }
}

// 测试
public static void main(String[] args) {
    Counter c = new Counter();
    ExecutorService executor = Executors.newFixedThreadPool(10);

    // 同时有10个线程对count进行自增和自减
    for (int i = 0; i < 10; i++) {
        executor.execute(() -> {
            c.increment();
            c.decrement();
        });
    }

    executor.shutdown();
    while (!executor.isTerminated()) {}

    System.out.println(c.getCount()); // 应该为0
}

3. 线程间的通信

多个线程之间需要通信时，可以使用wait、notify和notifyAll方法。其中wait方法会使当前线程进入等待状态，释放锁；而notify和notifyAll方法会唤醒在等待状态下的线程，让它们重新竞争锁。

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

    public synchronized String read() {
        while (empty) {
            try {
                wait(); // 进入等待状态
            } catch (InterruptedException e) {}
        }
        empty = true;
        notifyAll(); // 唤醒在等待状态下的线程

        return content;
    }

    public synchronized void write(String message) {
        while (!empty) {
            try {
                wait(); // 进入等待状态
            } catch (InterruptedException e) {}
        }
        empty = false;
        this.content = message;
        notifyAll(); // 唤醒在等待状态下的线程
    }
}

// 测试
public static void main(String[] args) {
    Message message = new Message();

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

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

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

以上就是Java多线程深入理解的攻略，希望可以帮助到大家。