Java多线程基础入门（一）

在Java编程中，多线程是一个重要的概念，它可以提高程序的性能和响应速度。本文将介绍如何在Java中实现多线程，并讨论一些常见的线程管理问题。

1. 创建线程的方式

在Java中，可以通过两种方式创建线程：

• 继承Thread类：通过继承Thread类并重写其run方法来创建线程。


• 实现Runnable接口：通过实现Runnable接口并实现run方法来创建线程。这种方式更灵活，可以实现多继承。

示例代码：继承Thread类

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

public class Main {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        System.out.println("运行结束!");
    }
}

示例代码：实现Runnable接口

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

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
        System.out.println("运行结束!");
    }
}

2. 线程的生命周期

线程的生命周期包括以下几个阶段：

• 新建（New）：线程对象被创建但尚未启动。


• 就绪（Runnable）：线程已准备好运行，正在等待CPU时间片。


• 运行（Running）：线程正在执行其run方法。


• 阻塞（Blocked）：线程因某种原因暂停执行，如等待I/O操作完成。


• 死亡（Dead）：线程的run方法执行完毕或因异常终止。

3. 线程的执行顺序

线程的执行顺序并不是固定的，而是由操作系统调度器决定的。调用start方法只是将线程置于就绪状态，具体的执行顺序由系统分配的时间片决定。

示例代码

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i <5000; i++) {
            System.out.println("i=" + i);
        }
        System.out.println("上面的循环执行完了");
        for (int j = 0; j <5000; j++) {
            System.out.println("j=" + j);
        }
        System.out.println("执行完毕");
    }
}

4. 线程安全问题

当多个线程访问同一个共享资源时，可能会出现线程安全问题。例如，多个线程同时修改同一个变量，会导致数据不一致。

示例代码

public class MyThread extends Thread {
    private int count = 5;
    
    @Override
    public synchronized void run() {
        while (count > 0) {
            count--;
            System.out.println("由 " + currentThread().getName() + " 计算, count=" + count);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread myThreadA = new MyThread();
        MyThread myThreadB = new MyThread();
        MyThread myThreadC = new MyThread();
        
        myThreadA.start();
        myThreadB.start();
        myThreadC.start();
    }
}

5. 解决线程安全问题的方法

解决线程安全问题的常见方法是使用同步机制，如synchronized关键字。synchronized可以确保同一时间只有一个线程可以访问特定的代码块或方法。

示例代码

public class MyThread extends Thread {
    private int i = 5;
    
    @Override
    public void run() {
        System.out.println("i=" + (i--) + " threadName=" + Thread.currentThread().getName());
    }
}

6. 线程的命名和初始化

在Java中，每个线程都有一个默认的名称，如“Thread-0”，“Thread-1”等。这些名称是在线程创建时自动生成的。可以通过Thread类的构造函数来指定线程的名称。

示例代码

public class MyThread extends Thread {
    @Override
    public void run() {}
}

public class Main {
    public static void main(String[] args) {
        MyThread myT = new MyThread();
        Thread t1 = new Thread(myT, "MyThread");
        t1.start();
    }
}

7. Thread.currentThread() 和 this.getName()

在多线程编程中，`Thread.currentThread()` 返回当前正在执行的线程对象，而 `this` 表示当前对象的引用。通过这两个方法，可以获取线程的名称和状态。

示例代码

public class CountOperate extends Thread {
    public CountOperate() {
        System.out.println("CountOperate---begin");
        System.out.println("Thread.currentThread().getName()=" + Thread.currentThread().getName());
        System.out.println("Thread.currentThread().isAlive()=" + Thread.currentThread().isAlive());
        System.out.println("this.getName()=" + this.getName());
        System.out.println("this.isAlive()=" + this.isAlive());
        System.out.println("CountOperate---end");
    }
    
    @Override
    public void run() {
        System.out.println("run---begin");
        System.out.println("Thread.currentThread().getName()=" + Thread.currentThread().getName());
        System.out.println("Thread.currentThread().isAlive()=" + Thread.currentThread().isAlive());
        System.out.println("this.getName()=" + this.getName());
        System.out.println("this.isAlive()=" + this.isAlive());
        System.out.println("run---end");
    }
}

public class Main {
    public static void main(String[] args) {
        CountOperate co = new CountOperate();
        co.start();
    }
}