// 使用空参构造方法创建多线程,并且使用默认线程名称
public Thread() {
    init(null, null, "Thread-" + nextThreadNum(), 0);
}
// 指定线程名名称创建多线程
public Thread(String name) {
    init(null, null, name, 0);
}
// 使用Runnable内部类创建或使用实现Runnable的子类创建多线程
public Thread(Runnable target) {
    init(null, target, "Thread-" + nextThreadNum(), 0);
}
// 使用Runnable内部类创建或使用实现Runnable的子类创建多线程,并且指定名称
public Thread(Runnable target, String name) {
    init(null, target, name, 0);
}
// 使用Runnable内部类创建或使用实现Runnable的子类创建多线程,并且指定分组
public Thread(ThreadGroup group, Runnable target) {
    init(group, target, "Thread-" + nextThreadNum(), 0);
}
// 创建多线程并指定分组名称以及线程名称
public Thread(ThreadGroup group, String name) {
    init(group, null, name, 0);
}
// 使用Runnable内部类创建或使用实现Runnable的子类创建多线程,并指定分组名称以及线程名称
public Thread(ThreadGroup group, Runnable target, String name) {
    init(group, target, name, 0);
}

public class MyThread extends Thread{  
    private String name;  
  
    public MyThread(String name) {  
        super(name);  
        this.name = name;  
    }  
  
    public MyThread() {  
    }    //如果想要实现多线程 必须重写run方法  
  
    @Override  
    public void run() {  
        //注释父类的调用自己实现  
        //super.run();  
        //写一个for循环代表多线程的执行逻辑  
        for (int i = 0; i < 10; i++) {  
            System.out.println(name+"线程执行："+i);  
        }  
    }  
}

public class ThreadDemo {  
    public static void main(String[] args) {  
		//创建多线程对象  
		MyThread myThread1=new MyThread("线程1");  
		//启动线程  
		//错误示范：  
		//myThread1.run();  
		//正确启动方式  
		myThread1.start();  
	
		MyThread myThread2=new MyThread("线程2");  
		myThread2.start();  
	
		System.out.println("程序结束...");  
    }  
}

public class MyThread implements Runnable{  
  
    //多线程执行的逻辑的方法  
    @Override  
    public void run() {  
        for (int i = 0; i < 10; i++) {  
            System.out.println("多线程执行："+i);  
        }  
    }  
}

public class ThreadDemo {  
    public static void main(String[] args) {  
        //创建线程类  
        MyThread myThread=new MyThread();  
        //创建线程对象  
        Thread thread1=new Thread(myThread);  
        Thread thread2=new Thread(myThread);  
  
        //启动线程  
        thread1.start();  
        thread2.start();  
  
        //使用内部类创建多线程  
        Thread thread3=new Thread(new Runnable(){  
            @Override  
            public void run() {  
                for (int i = 0; i < 10; i++) {  
                    System.out.println("匿名内部类多线程执行："+i);  
                }  
            }  
        });  
        //启动线程  
        thread3.start();  
        System.out.println("程序结束");  
    }  
}

//实现Callable接口并指定泛型类型-->泛型类型是Value,并且是多线程的返回值  
import java.util.concurrent.Callable;  
  
public class MyThread implements Callable<String> {  
/**  
 * call方法与之前的两种方式中的 run方法 相同，都是线程的执行体  
 * 不同点在于call有返回值  
 *  
 * @return 返回值  
 * @throws Exception 线程的异常  
 */  
  
    @Override  
    public String call() throws Exception {  
        for (int i = 0; i < 10; i++) {  
            System.out.println("线程执行"+i);  
        }  
        return "线程执行完毕";  
    }  
}

import java.util.concurrent.FutureTask;  
  
public class ThreadDemo {  
    public static void main(String[] args) throws Exception {  
        //创建线程  
        //1.创建实现Callable接口的类  
        MyThread myThread = new MyThread();  
        // 2. 使用FutureTask创建此线程,泛型类型与Callable实现时的相同  
        // 参数为Callable实现类  
        FutureTask<String> futureTask1=new FutureTask<>(myThread);  
        FutureTask<String> futureTask2=new FutureTask<>(myThread);  
        //3.创建线程类  
        Thread thread1=new Thread(futureTask1);  
        //4.启动线程  
        thread1.start();  
        Thread thread2=new Thread(futureTask2);  
        thread2.start();  
  
        // 5. 接收线程返回的参数使用public V get() throws InterruptedException, ExecutionException方法  
        // get方法会造成程序阻塞(会停止),等待接收线程返回的数据  
        String result1 = futureTask1.get();  
        System.out.println(result1);  
        String result2=futureTask2.get();  
        System.out.println(result2);  
  
        //最后输出程序结束  
        System.out.println("程序结束");  
    }  
}