Java实现在不同线程中运行的代码实例

我根据您的要求给出完整的Java实现在不同线程中运行的代码实例攻略。

概述

在Java中，使用线程来实现程序的并发执行。线程是进程中的子操作，每个线程都能并行执行。当然，这就要求我们在编写代码时考虑到线程安全和并发执行的要求，从而避免对数据的多个访问导致的不一致问题。

如何实现多线程

Java提供了两种方法实现多线程：

• 继承Thread类
• 实现Runnable接口

继承Thread类需要重写run()方法，并调用start()方法启动线程。代码如下：

public class MyThread extends Thread {
    public void run() {
        System.out.println("MyThread is running...");
    }
}

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

实现Runnable接口也需要重写run()方法，但是需要使用Thread类的构造方法将Runnable对象传递给Thread。代码如下：

public class MyRunnable implements Runnable {
    public void run() {
        System.out.println("MyRunnable is running...");
    }
}

MyRunnable mr = new MyRunnable();
Thread t = new Thread(mr);
t.start();

如何实现线程同步

当多个线程同时访问共享资源时，就会出现数据不一致的问题。这时就需要使用线程同步机制来保证数据的正确性。Java提供了关键字synchronized来实现线程同步，还提供了锁机制来实现精细化的线程同步。

关键字synchronized可以修饰代码块和方法，如下所示：

public static synchronized void test() {
    // ...
}

synchronized(obj) {
    // ...
}

锁机制主要是通过ReentrantLock类来实现，它提供了lock()和unlock()方法来分别获取和释放锁。代码如下：

ReentrantLock lock = new ReentrantLock();

lock.lock();
try {
    // ...
} finally {
    lock.unlock();
}

示例说明

示例一

下面是一个示例，其中使用继承Thread类的方法来创建一个多线程程序。每个线程打印5次自己的名字，并使用线程同步机制来保证每个线程的输出顺序一致。

public class MyThread extends Thread {
    private static int count = 0;
    private int id;

    public MyThread() {
        id = ++count;
    }

    public void run() {
        for (int i = 0; i < 5; i++) {
            synchronized(MyThread.class) {
                System.out.println("Thread-" + id + ": " + i);
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new MyThread().start();
        }
    }
}

输出结果：

Thread-1: 0
Thread-1: 1
Thread-1: 2
Thread-1: 3
Thread-1: 4
Thread-2: 0
Thread-2: 1
Thread-2: 2
Thread-2: 3
Thread-2: 4
Thread-3: 0
Thread-3: 1
Thread-3: 2
Thread-3: 3
Thread-3: 4
Thread-4: 0
Thread-4: 1
Thread-4: 2
Thread-4: 3
Thread-4: 4
Thread-5: 0
Thread-5: 1
Thread-5: 2
Thread-5: 3
Thread-5: 4

示例二

下面是另一个示例，其中使用实现Runnable接口的方法来创建一个多线程程序。每个线程打印5次自己的名字，并使用锁机制来保证每个线程的输出顺序一致。

public class MyRunnable implements Runnable {
    private static int count = 0;
    private int id;
    private ReentrantLock lock;

    public MyRunnable(ReentrantLock lock) {
        id = ++count;
        this.lock = lock;
    }

    public void run() {
        for (int i = 0; i < 5; i++) {
            lock.lock();
            try {
                System.out.println("Thread-" + id + ": " + i);
            } finally {
                lock.unlock();
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        for (int i = 0; i < 5; i++) {
            new Thread(new MyRunnable(lock)).start();
        }
    }
}

输出结果：

Thread-1: 0
Thread-1: 1
Thread-1: 2
Thread-1: 3
Thread-1: 4
Thread-2: 0
Thread-2: 1
Thread-2: 2
Thread-2: 3
Thread-2: 4
Thread-3: 0
Thread-3: 1
Thread-3: 2
Thread-3: 3
Thread-3: 4
Thread-4: 0
Thread-4: 1
Thread-4: 2
Thread-4: 3
Thread-4: 4
Thread-5: 0
Thread-5: 1
Thread-5: 2
Thread-5: 3
Thread-5: 4

以上是实现Java在不同线程中运行的代码实例的详细攻略和两条示例说明。

阅读剩余 75%