多线程的三种实现方式、三种内部类写法、常见函数使用举例

1、继承Thread类

public class ThreadTest01 {

    public static void main(String[] args) {
        MyThread myThread1 = new MyThread("周星驰");
        MyThread myThread2 = new MyThread("成龙");
        myThread1.start();
        myThread2.start();
    }
}
1.1、继承Thread类
1.2、复写run方法
1.3、new 新的类对象
1.4、调用新类的start方法
class MyThread extends Thread{
    private String name;
    public MyThread(String name){
        this.name = name;
    }
    public void run(){
        for(int i=0;i<100;i++){
            try {Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}
            System.out.println("------>"+name+"--->"+i);
        }
    }
}

2、实现Runnable接口（使用静态代理的方式实现的）

public class ThreadTest02 {
    public static void main(String[] args) {
        MyThread02 myThread1 = new MyThread02("周星驰");
        MyThread02 myThread2 = new MyThread02("成龙");
        Thread thread1 = new Thread(myThread1);
        Thread thread2 = new Thread(myThread2);
        thread1.start();
        thread2.start();
    }
}
2.1、实现Runnable接口
2.2、复写run方法
2.3、new 新的类对象
2.4、new一个Thread对象（传入上面的对象）
2.5、Thread对象调用start方法启动线程
class MyThread02 implements Runnable{
    private String name;
    public MyThread02(String name){
        this.name = name;
    }
    public void run() {
        for(int i=0;i<100;i++){
            try {Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}
            System.out.println("------>"+name+"--->"+i);
        }
    }
}

3、实现Callable接口

public class ThreadTest03 {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService ser = Executors.newFixedThreadPool(2);
        MyThread03 myThread1 = new MyThread03("周星驰");
        MyThread03 myThread2 = new MyThread03("成龙");
        Future<String> future1 =ser.submit(myThread1);
        Future<String> future2 =ser.submit(myThread2);
        Thread.sleep(5000);
        myThread1.setFlag(false);
        myThread2.setFlag(false);
        String result1 =future1.get();
        String result2 =future2.get();
        System.out.println("-----------------------");
        System.out.println(result1);
        System.out.println(result2);
                ser.shutdownNow();
    }
}
3.1、实现Callable接口
3.2、复写call方法（返回值类型需与Callable接口的泛型一致）
3.3、ExecutorService ser = Executors.newFixedThreadPool(2)创建一个线程池，用于启动线程
3.4、new一个线程对象
3.5、定义一个Future类型的参数接受线程池提交的线程对象后的“未来值”
3.6、通过Future的get()方法，获取到线程返回的值，该方法会阻塞线程，即调用该方法后，主线程会等到新启的线程
结束拿到结果后，才会执行后面的代码
3.7、调用shutdownNow()方法，关闭线程池（否则主线程不会结束）
class MyThread03 implements Callable<String>{
    private String name;
    private boolean flag =true;
    public MyThread03(String name){
        this.name = name;
    }
    public String call() throws Exception {
        int i = 0;
        while(flag){
            try {Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}
            i++;
            System.out.println("------>"+name+"--->"+i);
        }
        return name;
    }
    public boolean isFlag() {
        return flag;
    }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

4、三种特殊写法

public class ThreadTest04 {
    public static void main(String[] args) {
        new Thread(){
            private String name ="周星驰";
            public void run(){
                for(int i=0;i<100;i++){
                    try {Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}
                    System.out.println("------>"+name+"--->"+i);
                }
            }
        }.start();
        
        new Thread(new Runnable(){
            private String name ="成龙";
            public void run() {
                for(int i=0;i<100;i++){
                    try {Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}
                    System.out.println("------>"+name+"--->"+i);
                }
            }
        }).start();

                new Thread(new Thread(){
            private String name ="李连杰";
            public void run() {
                for(int i=0;i<100;i++){
                    try {Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}
                    System.out.println("------>"+name+"--->"+i);
                }
            }
        }).start();
    }
}

5、Join()方法，合并线程，是把被调用的线程合并到主线程中，并行变串行，主线程进入等待，直到被合并进来的线程执行完后，主线程才继续进行

public class ThreadTest05 extends Thread{
    private String name;
    public ThreadTest05(String name){
        this.name = name;
    }
    public static void main(String[] args) {
        ThreadTest05 threadTest05 = new ThreadTest05("成龙");
        Thread thread = new Thread(threadTest05);
        thread.start();
        
        for(int i=0;i<100;i++){
            if(i==50){try {thread.join();} catch (InterruptedException e) {e.printStackTrace();}}
            try {Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}
            System.out.println("------>main--->"+i);
        }
    }
    
    public void run(){
        for(int i=0;i<100;i++){
            try {Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}
            System.out.println("------>"+name+"--->"+i);
        }
    }
}

此程序先是两线程一起跑，等到主线程I==50时，主线程停下，等待子线程thread执行完，主线程才继续执行

6、yield()方法，暂停线程（把自己的CPU时间片让出），直到CPU再分给时间片才会继续运行，此方法为static方法，Thread.yield(),写在哪个线程，哪个线程就暂停，与sleep相似

public class ThreadTest06 extends Thread{
    private String name;
    public ThreadTest06(String name){
        this.name = name;
    }
    public static void main(String[] args) {
        ThreadTest06 threadTest06 = new ThreadTest06("成龙");
        Thread thread = new Thread(threadTest06);
        thread.start();
        
        for(int i=1;i<100;i++){
            if(i%20==0){Thread.yield();}
            System.out.println("------>main--->"+i);
        }
    }
    
    public void run(){
        for(int i=0;i<100;i++){
            System.out.println("------>"+name+"--->"+i);
        }
    }
}

7、Sleep()方法，让线程睡眠，static方法，太常见，例子略
Thread.currentThread()获取当前线程static方法，thread.setName("name")给线程设置名称，thread.getName()获取线程名称
thread.isAlive()判断线程是否是存活状态