Java多线程 实例解析

Java多线程 实例解析攻略

前言

Java中的多线程是Java程序员必须掌握的基础知识之一，Java中的多线程可以充分利用多核CPU的优势，提高程序的运行效率。在本篇文章中，我们将会详细讲解Java多线程的相关知识，包括：线程的概念、线程的生命周期、线程的状态、线程同步等。同时也会通过两个示例说明Java多线程的实现。

线程的概念

线程是一个程序中的执行流，每个程序至少会有一个线程。当程序启动时，操作系统会自动创建一个线程，这个线程被称为主线程。

Java中的线程是通过Thread类实现的，每一个线程都必须要实现run()方法。

线程的生命周期

Java中的线程拥有特定的生命周期，一个线程在创建之后，会经历以下5个阶段：

• 新建（New）： 当线程被创建但还没有在操作系统中创建对应的线程时，线程处于新建状态。
• 就绪（Runnable）：当线程在操作系统中创建了对应的线程，但还没开始运行时，线程处于就绪状态。
• 运行（Running）：当线程开始运行时，线程会进入到运行状态。
• 阻塞（Blocked）：当线程将正在执行的CPU时间片让给其他线程，以便其他线程执行，或者线程等待某个条件的释放时，线程处于阻塞状态。
• 终止（Terminated）：当线程完成了run()方法的执行，或者发生了异常而导致线程进程结束时，线程处于终止状态。

线程的状态

Java中的线程状态有以下几种：

• NEW： 线程被创建，但是没有开始运行。
• RUNNABLE：线程正在运行或者等待CPU时间片。
• WAITTING：线程处于等待状态，等待其他线程的通知或者指令。
• BLOCKED： 线程被阻塞，正在等待锁或者其他的同步机制。
• TIMED_WAITTING：线程等待特定的时间。

线程同步

线程同步主要是为了保证多个线程访问共享资源（比如一个变量或者一个文件）时，能够保证数据的正确性。Java中的线程同步可以通过synchronized关键字实现。

以下是一个简单的线程同步示例：

public class Counter implements Runnable {
    private int count = 0;

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

    public synchronized void decrement() {
        count--;
    }

    public void run() {
        increment();
        decrement();
    }

    public int getCount() {
        return count;
    }

    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread thread1 = new Thread(counter);
        Thread thread2 = new Thread(counter);
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch(InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Counter count: " + counter.getCount());
    }
}

在上面的示例中，Counter类实现了Runnable接口，同时定义了一个count变量和increment()、decrement()方法，这两个方法都被synchronized修饰。接着我们创建了两个线程，并且让这两个线程都执行Counter的run()方法。在Counter的run()方法中，我们让线程先执行increment()方法，然后再执行decrement()方法，这样就会产生竞争条件，当两个线程同时访问时，操作会产生错误。

在Counter的main()方法中，我们创建了两个线程，然后启动这两个线程，最后用join()方法等待两个线程执行完毕。最后输出count的值，可以发现通过使用synchronized关键字，线程访问count变量的时候都是串行化执行的，从而避免了竞争条件的发生，数据的正确性得到了保证。

示例说明

下面是一个简单的线程优先级示例：

public class PriorityDemo implements Runnable{
    private int priority;
    private String name;

    public PriorityDemo(String name, int priority){
        this.name = name;
        this.priority = priority;
    }

    public void run() {
        for (int i=0; i<10; i++) {
            Thread.yield();
            System.out.println(this.name + " is running!");
        }
    }
    public static void main(String[] args){
        PriorityDemo pd1 = new PriorityDemo("Thread1", Thread.MIN_PRIORITY);
        PriorityDemo pd2 = new PriorityDemo("Thread2", Thread.MAX_PRIORITY);
        Thread t1 = new Thread(pd1);
        Thread t2 = new Thread(pd2);
        t1.start();
        t2.start();
    }
}

在上面的示例中，我们定义了PriorityDemo类实现了Runnable接口，同时定义了一个构造方法，用来初始化线程的名称和优先级。在PriorityDemo的run()方法中，我们使用Thread.yield()方法模拟了线程执行过程中的暂停，当线程执行到此方法时，会将CPU时间片让给其他线程。

在PriorityDemo的main()方法中，我们创建了两个线程t1和t2，并将这两个线程分别传入两个不同的PriorityDemo对象中。其中t1的优先级设置为Thread.MIN_PRIORITY，也就是最低的优先级，而t2的优先级设置为Thread.MAX_PRIORITY，也就是最高的优先级。接着我们启动这两个线程，可以看到代码执行的结果，两个线程交替执行，但是t2的执行次数比t1的多很多，因为线程优先级的差别导致了t2的执行更频繁。

总结

Java中的多线程是Java程序员必须掌握的基础知识之一，本文从线程的概念、生命周期、状态和同步等方面讲解了基本知识，并通过两个示例说明了Java多线程的实现方法。希望对读者理解Java多线程有所帮助。