线程开启的三种方式（一个类两个接口）

第1种方式：继承Thread类（重写run方法）
实现部分：

public class MyThread extends Thread{

    //定义指定线程名称的构造方法
    public MyThread(String name) {
        //调用父类的String参数的构造方法，指定线程的名称
        super(name);
    }
    public MyThread() {
        // TODO Auto-generated constructor stub
    }
    /**
     * 重写run方法，完成该线程执行的逻辑
     */
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"：正在执行！"+i);
        }
    }
}

Thread.currentThread().getName()是获得当前执行的线程名字
测试部分：

public class Demo {
    public static void main(String[] args) {
        //创建自定义线程对象
        MyThread mt = new MyThread("新的线程！");

        //开启新线程
        mt.start();
        //在主方法中执行for循环
        for (int i = 0; i < 10; i++) {
            System.out.println("main线程！"+i);
        }
    }
}

注意
1.由于java是抢占式调度，在优先级相同的情况下，会随机选择一个线程，造成每次运行结果不同。
2.创建实现类对象调用run（）方法不能开启线程，调用start()方法才能开启线程
第2种方式：实现Runnable接口（重写run方法）
实现部分：

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"我的线程：正在执行！"+i);
        }

    }

}

测试部分：

public class Demo02 {
    public static void main(String[] args) {
        //创建线程执行目标类对象
        Runnable runn = new MyRunnable();
        //将Runnable接口的子类对象作为参数传递给Thread类的构造函数
        Thread thread = new Thread(runn);
        Thread thread2 = new Thread(runn);
        //开启线程
        thread.start();
        thread2.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("main线程：正在执行！"+i);
        }
    }
}

实现接口的好处：
实现Runnable接口避免了单继承的局限性，所以较为常用。实现Runnable接口的方式，更加的符合面向对象，线程分为两部分，一部分线程对象，一部分线程任务。继承Thread类，线程对象和线程任务耦合在一起。一旦创建Thread类的子类对象，既是线程对象，有又有线程任务。实现runnable接口，将线程任务单独分离出来封装成对象，类型就是Runnable接口类型。Runnable接口对线程对象和线程任务进行解耦。
第3种方式：线程池（实现callable接口，重写call()方法）
实现部分：

public class Mcallbale implements Callable<String> {

    @Override
    public String call() throws Exception {
        // TODO Auto-generated method stub
        return "线程池方式";
    }

}
public class Pool {
    public static void main(String[] args) {
        //开启线程池,初始化线程池的个数
        ExecutorService service=Executors.newFixedThreadPool(3);
        //  创建接口实现类 
        Mcallbale mt=new Mcallbale();
        //从线程池中获取线程对象,然后调用MyRunnable中的run()
        //注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。将使用完的线程又归还到了线程池中
        //Future接口：用来记录线程任务执行完毕后产生的结果。
        Future<String> f=service.submit(mt);
        try {
            //获得线程池里面的内容
            System.out.println(f.get());
        } catch (InterruptedException e) {

            e.printStackTrace();
        } catch (ExecutionException e) {

            e.printStackTrace();
        }
    }   
}

总结：线程的创建和销毁是开销比较大的，在多线程的情况下尽量使用线程池。