Java多线程在Ubuntu下的实现

在Ubuntu环境下用Java实现多线程，核心思路主要有两种：继承Thread类，或者实现Runnable接口。两种方式各有适用场景，但底层逻辑一致——都是把并发任务交给JVM的线程调度器。下面直接介绍具体实现步骤。

方法一：继承Thread类

1. 新建一个类，让它继承Thread，然后重写run()方法——线程要执行的任务就写在这里：

   class MyThread extends Thread {
       @Override
       public void run() {
           // 线程执行的代码
           System.out.println("线程正在运行: " + Thread.currentThread().getName());
       }
   }

2. 创建实例，调用start()方法启动线程。注意是start()而不是run()，直接调run()等于普通方法调用，不会创建新线程：

   public class Main {
       public static void main(String[] args) {
           MyThread thread1 = new MyThread();
           MyThread thread2 = new MyThread();
           thread1.start(); // 启动线程1
           thread2.start(); // 启动线程2
       }
   }

方法二：实现Runnable接口

比起继承，更推荐的做法是实现Runnable接口——避免单继承的限制，还能方便地共享数据。

1. 写一个类实现Runnable，同样在run()里编写逻辑：

   class MyRunnable implements Runnable {
       @Override
       public void run() {
           // 线程执行的代码
           System.out.println("线程正在运行: " + Thread.currentThread().getName());
       }
   }

2. 把这个Runnable对象传给Thread构造器，然后启动：

   public class Main {
       public static void main(String[] args) {
           MyRunnable runnable = new MyRunnable();
           Thread thread1 = new Thread(runnable);
           Thread thread2 = new Thread(runnable);
           thread1.start(); // 启动线程1
           thread2.start(); // 启动线程2
       }
   }

注意事项

多线程代码虽然写起来简单，但常见的问题往往隐藏在并发执行中：

• 线程安全：多个线程同时读写同一个变量，数据错乱是大概率事件。需要借助同步机制来保证。
• 线程同步：使用synchronized关键字给代码块加锁，或者用Lock接口的显式锁，都能确保同一时刻只有一个线程访问临界区。
• 线程间通信：wait()、notify()、notifyAll()这三个方法配合synchronized块，可以让线程之间互相协调。

示例代码

下面这个例子将上述要点整合在一起：两个线程共享一个MyRunnable实例，通过synchronized保证计数器安全递增，同时让每个线程每次循环后休眠1秒，防止输出过快：

class MyRunnable implements Runnable {
    private int count = 0;

    @Override
    public void run() {
        while (count < 5) {
            synchronized (this) {
                System.out.println("线程 " + Thread.currentThread().getName() + " 计数: " + count);
                count++;
                try {
                    Thread.sleep(1000); // 让线程休眠1秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread thread1 = new Thread(runnable, "线程1");
        Thread thread2 = new Thread(runnable, "线程2");
        thread1.start();
        thread2.start();
    }
}

运行后可以看到两个线程交替打印计数，每次输出之间停顿1秒，并且数字不会错乱——这正是同步机制的作用。