多线程的实现方式

1. 通过继承Thread类实现：

public class MyThread extends Thread{
    @Override
    public void run() {
		//一个类中可以定义很多方法，规定run（）方法是由线程去执行的
        //一般线程用来处理那些耗时的操作
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
        }
    }

   
}

//测试类：
 	public class MyTest {
  
    public static void main(String[] args) {
		//获取当前的主线程对象
        Thread thread = Thread.currentThread();
        //设置线程的名称
        thread.setName("主线程");
        //获取主线程名称；
        String name = thread.getName();
        System.out.println(name);
     
        //创建线程
        MyThread myThread = new MyThread();
        //开启线程
        myThread.start(); //正确的开启线程:由java虚拟机调用任务的run方法执行；
        
        //设置线程的名称
        myThread.setName("范冰冰");
        
        MyThread myThread1 = new MyThread();
        myThread1.start();

        //上面开启的线程，并发的去执行
    }

}

        

2. 实现Runnable接口：
定义实现Runnable接口的子类并重写接口中的run()方法;
在主线程创建接口的子类对象；创建Thread类的对象，传入接口的子类对象，开启线程；

public class MyTest {
    public static void main(String[] args) {
    
        MyRunnable runable = new MyRunnable();
        Thread thread = new Thread(runable);
        thread.setName("范冰冰");
        thread.start();
    }
 //创建的实现Runnable类的子类对象；
public class MyRunnable  implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            Thread thread = Thread.currentThread();
            String name = thread.getName();
            System.out.println(name+"==="+i);
        }
    }
}

3. 实现Callable接口：
创建实现Callable的类，重写call方法；
创建FutureTask类对象，将接口的子类对象传入；
创建Thread类对象，将FutureTask类对象传入；
开启线程，其中FutureTask类里面能够获得线程执行完返回的结果。

public class MyTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建线程任务；
        MyCallable myCallable = new MyCallable(1000);
        
        //FutureTask 这个类里面能够获取线程执行完之后的返回的结果
        FutureTask<Integer> integerFutureTask = new FutureTask<>(myCallable);
        Thread thread = new Thread(integerFutureTask);
        thread.start();
        
        //获取到子线程执行完之后的结果
        Integer integer = integerFutureTask.get();
        System.out.println(integer);

    }
}


public class MyCallable implements Callable<Integer> {
    int num;
    public MyCallable(int i) {
        num=i;
    }

    //call 方法 就是线程来执行的
    @Override
    public Integer call() throws Exception {
        Thread thread = Thread.currentThread();
        String name = thread.getName();
        int sum=0;
        for (int i = 1; i <=num; i++) {

            sum+=i;
        }
        return sum;
    }
}

匿名内部类创建线程：

public class MyTest {
    public static void main(String[] args) {
       //方式1
        new Thread(){
            @Override
            public void run() {
                System.out.println("线程执行了");
            }
        }.start();
        new Thread() {
            @Override
            public void run() {
                System.out.println("线程执行了");
            }
        }.start();
        
        //方式2
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("任务执行了");
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("任务执行了");
            }
        }).start();
    }
}