Java语言规范线程形式范例(Java线程规范实例详解)

原创

ithorizon 6个月前 (10-21) 阅读数 21 #后端开发

Java语言规范线程形式范例 - Java线程规范实例详解

一、Java线程概述

在Java中，线程是程序的基本执行单元。Java提供了两种创建线程的方案：通过继承Thread类和实现Runnable接口。Java线程的运行遵循一定的规范，下面我们将通过一些实例来详细解释Java线程的规范。

二、继承Thread类创建线程

这种方案是最易懂的一种创建线程的方法。下面是一个易懂的例子：


public class MyThread extends Thread {
    public void run() {
        System.out.println("线程运行中...");
    }
}
public class Main {
    public static void main(String[] args) {
        MyThread t = new MyThread();
        t.start();
    }
}

在这个例子中，我们创建了一个名为MyThread的类，它继承自Thread类，并重写了run()方法。在main方法中，我们创建了一个MyThread的实例，并调用start()方法启动线程。

三、实现Runnable接口创建线程

这种方案更加灵活，考虑到它允许你的类继承其他类。下面是一个例子：


public class MyRunnable implements Runnable {
    public void run() {
        System.out.println("线程运行中...");
    }
}
public class Main {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread t = new Thread(myRunnable);
        t.start();
    }
}

在这个例子中，我们创建了一个名为MyRunnable的类，它实现了Runnable接口，并实现了run()方法。在main方法中，我们创建了一个MyRunnable的实例，并将其传递给Thread的构造函数，然后调用start()方法启动线程。

四、线程的同步

当多个线程访问共享资源时，需要通过同步来避免数据不一致的问题。Java提供了synchronized关键字来实现同步。下面是一个易懂的例子：


public class Counter {
    private int count = 0;
    public synchronized void increment() {
        count++;
    }
    public int getCount() {
        return count;
    }
}
public class MyThread extends Thread {
    private Counter counter;
    public MyThread(Counter counter) {
        this.counter = counter;
    }
    public void run() {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
        }
    }
}
public class Main {
    public static void main(String[] args) {
        Counter counter = new Counter();
        MyThread t1 = new MyThread(counter);
        MyThread t2 = new MyThread(counter);
        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("计数器的值为: " + counter.getCount());
    }
}

在这个例子中，我们创建了一个名为Counter的类，它有一个名为count的私有变量和一个同步方法increment()。MyThread类继承自Thread，并在run()方法中调用increment()方法1000次。在main方法中，我们创建了Counter的一个实例和两个MyThread的实例，它们共享同一个Counter实例。通过调用join()方法，我们等待所有线程完成，然后打印计数器的值。

五、线程间的通信

线程间的通信可以通过wait(), notify()和notifyAll()这三个方法实现。下面是一个生产者-消费者模式的例子：


public class ProducerConsumerExample {
    private static final int CAPACITY = 10;
    private int count = 0;
    private final int[] buffer = new int[CAPACITY];
    public synchronized void produce(int item) throws InterruptedException {
        while (count == CAPACITY) {
            wait();
        }
        buffer[count++] = item;
        System.out.println("生产者生产了一个元素: " + item);
        notifyAll();
    }
    public synchronized int consume() throws InterruptedException {
        while (count == 0) {
            wait();
        }
        int item = buffer[0];
        System.arraycopy(buffer, 1, buffer, 0, count - 1);
        count--;
        System.out.println("消费者消费了一个元素: " + item);
        notifyAll();
        return item;
    }
}
public class Producer extends Thread {
    private ProducerConsumerExample example;
    public Producer(ProducerConsumerExample example) {
        this.example = example;
    }
    public void run() {
        try {
            for (int i = 0; i < 20; i++) {
                example.produce(i);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public class Consumer extends Thread {
    private ProducerConsumerExample example;
    public Consumer(ProducerConsumerExample example) {
        this.example = example;
    }
    public void run() {
        try {
            while (true) {
                example.consume();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public class Main {
    public static void main(String[] args) {
        ProducerConsumerExample example = new ProducerConsumerExample();
        Thread producer = new Producer(example);
        Thread consumer = new Consumer(example);
        producer.start();
        consumer.start();
    }
}

在这个例子中，我们创建了一个名为ProducerConsumerExample的类，它包含一个缓冲区和一个同步方法produce()和consume()。Producer类和Consumer类分别继承自Thread，并在它们的run()方法中调用produce()和consume()方法。在main方法中，我们创建了一个ProducerConsumerExample的实例和一个Producer和Consumer的实例，并启动它们。

六、线程的调度

Java提供了线程调度器，它可以利用线程的优先级来调度线程。下面是一个易懂的例子：


public class MyThread extends Thread {
    public MyThread(String name) {
        super(name);
    }
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(this.getName() + " 运行次数: " + i);
        }
    }
}
public class Main {
    public static void main(String[] args) {
        MyThread t1 = new MyThread("线程1");
        MyThread t2 = new MyThread("线程2");
        t1.setPriority(Thread.MIN_PRIORITY);
        t2.setPriority(Thread.MAX_PRIORITY);
        t1.start();
        t2.start();
    }
}

在这个例子中，我们创建了一个名为MyThread的类，它继承自Thread，并接受一个名字作为参数。在main方法中，我们创建了两个MyThread的实例，并设置了它们的优先级。线程1的优先级设置为最低，而线程2的优先级设置为最高。然后我们启动这两个线程。

七、线程的生命周期

Java线程的生命周期包括：新建、就绪、运行、阻塞、死亡。下面是一个易懂的例子，展示了线程的生命周期：


public class MyThread extends Thread {
    public MyThread(String name) {
        super(name);
    }
    public void run() {
        System.out.println(this.getName() + " is running.");
    }
}
public class Main {
    public static void main(String[] args) throws InterruptedException {
        MyThread t1 = new MyThread("线程1");
        System.out.println(t1.getName() + " is new.");
        t1.start();
        System.out.println(t1.getName() + " is running.");
        t1.join();
        System.out.println(t1.getName() + " is terminated.");
    }
}