Java启动线程的方法

一、使用Thread类启动线程

Java中启动线程的最简单方法就是使用Thread类。Thread类提供了很多启动线程的方法，但是其中最常用的方法是调用Thread对象的start()方法。

public class MyThread extends Thread {
    public void run() {
        //线程执行代码
    }
}

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

上述代码中，MyThread类继承自Thread类，并且重写了run()方法。在main()方法中，通过创建MyThread对象myThread，并调用其start()方法启动线程。

二、使用Runnable接口启动线程

除了使用Thread类外，Java还提供了另一种启动线程的方法，那就是实现Runnable接口。与Thread类不同的是，Runnable接口只定义了run()方法，需要通过Thread类的构造函数将其与Thread对象关联起来。

public class MyRunnable implements Runnable {
    public void run() {
        //线程执行代码
    }
}

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

上述代码中，MyRunnable类实现了Runnable接口，并重写了run()方法。在main()方法中，创建MyRunnable对象myRunnable，并将其关联到Thread对象上，最后启动线程。

三、使用匿名内部类启动线程

除了以上两种方法外，Java还提供了第三种启动线程的方法，那就是使用匿名内部类。这种方法可以让代码更加简洁，但是也比较难以阅读。

public class Main {
    public static void main(String args[]) {
        Thread thread = new Thread(new Runnable() {
            public void run() {
                //线程执行代码
            }
        });
        thread.start();
    }
}

上述代码中，通过创建一个匿名内部类实现Runnable接口，并在其中重写run()方法。然后将该对象关联到Thread对象上，并启动线程。

四、使用线程池启动线程

线程池是一种常用于控制多线程的技术，通过线程池可以避免直接使用Thread类造成的频繁创建和销毁线程的开销。在Java中，可以使用Executor框架提供的线程池来启动线程。

public class MyRunnable implements Runnable {
    public void run() {
        //线程执行代码
    }
}

public class Main {
    public static void main(String args[]) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for(int i=0; i<100; i++) {
            executorService.execute(new MyRunnable());
        }
        executorService.shutdown();
    }
}

上述代码中，创建了一个固定大小的线程池。在循环中，使用execute()方法提交100个MyRunnable对象，由线程池中的线程执行。最后通过shutdown()方法关闭线程池。

五、线程启动顺序的不确定性

无论采用哪种方法启动线程，都不存在确定性的启动顺序。线程的顺序是由操作系统调度决定的，开发人员不能对其进行干涉。

在以下代码中，无论线程A和B的start()方法谁先被执行，线程的启动顺序并不能确定。

public class Main {
    public static void main(String args[]) {
        Thread threadA = new Thread(new Runnable() {
            public void run() {
                //线程A执行代码
            }
        });
        Thread threadB = new Thread(new Runnable() {
            public void run() {
                //线程B执行代码
            }
        });
        threadA.start();
        threadB.start();
    }
}

六、线程启动的重复性

Thread对象的start()方法只能被调用一次。如果尝试对同一个Thread对象调用多次start()方法，则会在第二次调用时抛出IllegalThreadStateException异常。

public class MyThread extends Thread {
    public void run() {
        //线程执行代码
    }
}

public class Main {
    public static void main(String args[]) {
        MyThread myThread = new MyThread();
        myThread.start();
        myThread.start();  //会抛出IllegalThreadStateException异常
    }
}

七、线程启动的安全性

在多线程环境下，需要考虑线程启动的安全性。如果多个线程同时对同一个Thread对象调用start()方法，会导致该线程被多次启动，从而导致不确定的行为。

在以下代码中，如果多个线程都同时调用start()方法，线程A就有可能被多次启动，并导致不同步的问题。

public class Main {
    private static Thread threadA = new Thread(new Runnable() {
        public void run() {
            //线程A执行代码
        }
    });

    public static void main(String args[]) {
        Thread threadB = new Thread(new Runnable() {
            public void run() {
                threadA.start();
            }
        });
        Thread threadC = new Thread(new Runnable() {
            public void run() {
                threadA.start();
            }
        });
        threadB.start();
        threadC.start();
    }
}

为了确保线程的启动安全性，在多线程环境下应该尽量避免对同一个Thread对象调用start()方法。