Java线程编程中Thread类的基础学习教程

Java线程编程中Thread类的基础学习教程

什么是Java线程？

在计算机科学中，线程是进程中的一段指令执行路径；或者说是CPU调度的最小单位。与进程相比，线程更加轻量级，可以提高CPU利用效率，充分发挥计算机的计算能力。在Java中，线程是指实现了java.lang.Thread类或者java.lang.Runnable接口的对象。

Thread类的基础知识

Java中的线程是通过java.lang.Thread类来实现的，Thread类是一个被公认的非常好用的类，可以利用它的一系列API来实现线程的管理。在Java中，一个程序默认就只有一个线程-主线程（main thread），而主线程可以通过创建其他线程的方式来实现并发执行。

在使用Thread类时，需要注意以下几个方面：

1. 创建线程的两种方法：继承Thread类或者实现Runnable接口；
2. 启动线程的方式: start()方法；
3. 终止线程的方式：stop()方法已经被废弃，可以使用interrupt()和isInterrupted()方法实现；
4. 其他方法：sleep()、yield()、join()等。

继承Thread类的方式创建线程

继承Thread类创建线程非常简单，只需要重写run()方法并实例化对象即可。

public class MyThread extends Thread {
    private String threadName;

    public MyThread(String threadName) {
        this.threadName = threadName;
    }

    @Override
    public void run() {
        System.out.println(threadName + " is running.");
    }
}

在上述代码中，我们自定义了一个MyThread类，继承了Thread类，并在其构造方法中传递了线程名。在run()方法中实现了线程执行的具体内容。

为了启动线程，需要先实例化MyThread类，并调用其start()方法：

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

实现Runnable接口的方式创建线程

实现Runnable接口创建线程需要以下步骤：

1. 定义一个类实现Runnable接口；
2. 实现Runnable接口中的run()方法；
3. 然后将该实现类的实例作为参数传递到Thread类的构造函数中；
4. 最后启动线程。

public class MyRunnable implements Runnable {
    private String threadName;

    public MyRunnable(String threadName) {
        this.threadName = threadName;
    }

    @Override
    public void run() {
        System.out.println(threadName + " is running.");
    }
}

在上述代码中，我们自定义了一个MyRunnable类，实现了Runnable接口，并在其构造方法中传递了线程名。在run()方法中实现了线程执行的具体内容。

在实例化Thread类时需要传递MyRunnable的实例：

public class Main {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable("Thread2");
        Thread t2 = new Thread(myRunnable);
        t2.start();
    }
}

示例1：让两个线程先后执行

public class MyThread extends Thread {
    private String threadName;

    public MyThread(String threadName) {
        this.threadName = threadName;
    }

    @Override
    public void run() {
        System.out.println(threadName + " is running.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread t1 = new MyThread("Thread1");
        MyThread t2 = new MyThread("Thread2");
        t1.start();
        try {
            // t1线程执行完之后再执行t2线程
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        t2.start();
    }
}

在上述案例中，我创建了两个线程MyThread t1和MyThread t2，分别输出"Thread1 is running."和"Thread2 is running."信息。并通过t1.join()方法实现让Thread2等待Thread1执行完后再执行，从而保证了线程执行顺序。

示例2：利用Runnable实现线程同步和资源共享

public class MyRunnable implements Runnable {
    private int ticket = 10;

    @Override
    public void run() {
        // 此处同步锁为当前对象
        synchronized (this) {
            for (int i = 0; i < 10; i++) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "卖出了第" + ticket + "张票。");
                    ticket--;
                }
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread t1 = new Thread(myRunnable);
        Thread t2 = new Thread(myRunnable);
        t1.start();
        t2.start();
    }
}

在上述案例中，我们创建了一个MyRunnable类，共享了一个私有变量ticket，并实现了Runnable接口中的run()方法，在其中通过synchronized实现线程同步，保证了并发执行时ticket的值不会超过10。

在Main类中，我创建了两个线程t1和t2，共享了MyRunnable实例，分别执行了t1.start()和t2.start()方法，最终输出了线程ID，以及每个线程所卖出的票数。