使用Thread实现Java多线程编程

Java中的线程是一种轻量级的进程，它可以实现多个任务同时运行，提高了程序的性能。使用Thread类和Runnable接口可以方便地实现Java多线程编程。

一、创建线程

Java中使用Thread类来创建一个线程。继承Thread类，重写run()方法，并在该方法中定义需要执行的任务。

class MyThread extends Thread {
    public void run() {
        // 执行任务
    }
}

使用start()方法来启动这个线程。当start()被调用时，它会在一个新线程上执行run()方法。

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

当线程开始执行时，它会执行run()方法中定义的任务。

二、实现Runnable接口

除了继承Thread类来创建一个线程，还可以实现Runnable接口来创建一个线程。Runnable接口代表了一个可以被线程执行的任务。使用实现了Runnable接口的类创建线程，它的实例代表了一个可执行的任务。

class MyRunnable implements Runnable {
    public void run() {
        // 执行任务
    }
}

MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start();

使用Thread对象执行实现了Runnable接口的类的实例，调用Thread类的start()方法来启动这个线程，会在新线程上执行实现Runnable接口的类的实例的run()方法。

三、线程同步

在多线程编程中，有可能会出现多个线程同时访问共享的资源的情况，这时就需要用到线程同步。

Java中使用synchronized关键字来实现线程同步。synchronized关键字可以用来修饰方法、代码块、静态方法和类等。当一个线程访问synchronized代码块时，其他线程需要等待该线程执行完毕后才能访问该代码块。

例如：

class MyThread {
    private int count;

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

    public synchronized int getCount() {
        return count;
    }
}

在这个例子中，两个方法都被synchronized修饰，保证了多个线程同时访问count变量时，只有一个线程能够访问它。

四、线程优先级

在Java中，每个线程都有一个优先级，可以使用setPriority()方法来设置线程的优先级。优先级越高的线程会更容易地获取CPU资源。

线程的优先级被定义为数字1到10，1是最低优先级，而10是最高优先级。可以使用Thread类的常量MIN_PRIORITY、NORM_PRIORITY和MAX_PRIORITY分别来表示最低、默认、最高优先级。

例如：

MyThread thread1 = new MyThread();
thread1.setPriority(Thread.MAX_PRIORITY);

MyThread thread2 = new MyThread();
thread2.setPriority(Thread.MIN_PRIORITY);

MyThread thread3 = new MyThread();
thread3.setPriority(Thread.NORM_PRIORITY);

五、线程阻塞

线程阻塞是指线程暂停执行，直到一个特定的条件得到满足。

Java中有几种常见的线程阻塞方法，包括sleep、wait和join。

sleep方法可以用来暂停当前线程的执行，等待一定的时间后再继续执行。

try {
    Thread.sleep(1000); // 暂停一秒钟
} catch (InterruptedException e) {
    e.printStackTrace();
}

wait方法是一种方式，可以用来让线程进入等待状态，直到被唤醒。

synchronized (object) {
    try {
        object.wait(); // 线程进入等待状态
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

join方法是一种方式，可以等待另一个线程的结束。

Thread thread1 = new Thread();
Thread thread2 = new Thread();

thread1.start();
try {
    thread1.join(); // 等待thread1线程执行完
} catch (InterruptedException e) {
    e.printStackTrace();
}
thread2.start();

在这个例子中，thread1线程会先执行，执行完后，主线程会等待它执行结束后再执行thread2线程。

六、总结

Java中的线程模型非常灵活，可以通过继承Thread类或实现Runnable接口来创建线程，通过synchronized关键字来实现线程同步，通过设置线程优先级和线程阻塞等机制来调整线程的执行顺序。

下面是一个完整的示例代码：

class MyThread extends Thread {
    private int count;

    public MyThread(int count) {
        this.count = count;
    }

    public void run() {
        for (int i = 0; i < count; i++) {
            System.out.println("Thread-" + Thread.currentThread().getId() + " count: " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread(5);
        thread1.setPriority(Thread.MAX_PRIORITY);

        MyThread thread2 = new MyThread(5);
        thread2.setPriority(Thread.MIN_PRIORITY);

        MyThread thread3 = new MyThread(5);
        thread3.setPriority(Thread.NORM_PRIORITY);

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