关于java:Java中的线程创建和启动

35次阅读

共计 1973 个字符，预计需要花费 5 分钟才能阅读完成。

Java 应用 Thread 类代表线程，所有的线程对象都必须是 Thread 类或者其子类的实例。每个线程的作用是实现肯定的工作，实际上就是执行一段程序流（一段程序执行的代码）。Java 应用线程执行体来代表这段程序流。

通过继承 Thread 类来创立并启动多线程的步骤如下：

定义 Thread 类的子类，并重写该类的 run() 办法，该 run() 办法的办法体就代表了线程须要实现的工作。因而把 run() 办法称为线程执行体。
创立 Thread 子类的实例，即创立了线程对象。
调用线程对象的 start() 办法来启动该线程。

public class MyThread extends Thread {
    @Override
    public void run() {for (int i = 1; i <= 5; i++) {
            // 返回以后线程的名字
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }

    public static void main(String[] args) {for (int i = 1; i <= 6; i++) {
            // 获取以后线程的名字
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 3) {
                // 创立第一个线程
                MyThread thread1 = new MyThread();
                // 启动第一个线程
                thread1.start();

                // 创立第二个线程
                MyThread thread2 = new MyThread();
                // 启动第二个线程
                thread2.start();}
        }
    }
}

/*
    // 输入后果：main 1
    main 2
    main 3
    main 4
    main 5
    main 6
    Thread-1 1
    Thread-0 1
    Thread-1 2
    Thread-0 2
    Thread-1 3
    Thread-0 3
    Thread-1 4
    Thread-0 4
    Thread-1 5
    Thread-0 5
 */

 // 或者

 /*
    // 输入后果：main 1
    main 2
    main 3
    main 4
    main 5
    main 6
    Thread-0 1
    Thread-1 1
    Thread-0 2
    Thread-1 2
    Thread-0 3
    Thread-1 3
    Thread-0 4
    Thread-1 4
    Thread-0 5
    Thread-1 5
*/

其中，第一个线程和第二个线程的执行程序，每次运行先后顺序可能不肯定雷同，得依据虚拟机的线程调度器的调度。

实现 Runnable 接口来创立并启动多线程的步骤如下：

定义 Runnable 接口的实现类，并重写该接口的 run() 办法，该 run() 办法的办法体同样是该线程的线程执行体。
创立 Runnable 实现类的实例，并以此实例作为 Thread 的 target 来创立 Thread 对象，该 Thread 对象才是真正的线程对象。

public class MyThread implements Runnable {
    @Override
    public void run() {for (int i = 1; i <= 5; i++) {
            // 返回以后线程的名字
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }

    public static void main(String[] args) {for (int i = 1; i <= 6; i++) {
            // 获取以后线程的名字
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 3) {
                // 创立 Runnable 的实例：MyThread
                MyThread myThread = new MyThread();

                // 创立第一个线程，并将 Runnable 的实例：MyThread，作为 Thread 的 target 来创立 Thread 对象
                Thread thread1 = new Thread(myThread, "第一个线程");
                // 启动第一个线程
                thread1.start();

                // 创立第二个线程
                Thread thread2 = new Thread(myThread, "第二个线程");
                // 启动第二个线程
                thread2.start();}
        }
    }
}

 /*
    // 输入后果：main 1
    main 2
    main 3
    main 4
    main 5
    main 6
    第一个线程 1
    第二个线程 1
    第一个线程 2
    第二个线程 2
    第一个线程 3
    第二个线程 3
    第一个线程 4
    第二个线程 4
    第一个线程 5
    第二个线程 5
*/

// 或者

/*
    // 输入后果：main 1
    main 2
    main 3
    main 4
    main 5
    main 6
    第二个线程 1
    第一个线程 1
    第二个线程 2
    第一个线程 2
    第二个线程 3
    第一个线程 3
    第二个线程 4
    第一个线程 4
    第二个线程 5
    第一个线程 5
*/