java多线程三种实现

package rejava3.线程;

import javax.swing.*;
import javax.swing.plaf.nimbus.State;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.*;

class MyThread1 extends Thread{          //一个线程一个类且继承Thread
    boolean flag=true;
    public String people;
    public MyThread1(String people){
        this.people=people;
    }

    public void run(){
        Date tim=null;
        for(int o=0;o<10;o++){     //跟踪系统时间
            try {
                tim=new Date(System.currentTimeMillis());
                Thread.sleep(1000);               //sleep(int i);ms ;有异常抛出，延时结束后线程进入就绪状态
                System.out.println("系统时间"+new SimpleDateFormat("HH:mm:ss").format(tim));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void autoStop(){       //自己设置标志位让线程自动停下,用JDK强制的不好
        this.flag=false;
    }
}

class MyThread2 implements Runnable {      //如果MyThread有继承其它类则无法继承Thread类，实现接口Runnable
    String name;

    public MyThread2(String name) {
        this.name = name;
    }

    public void run() {
        for (int i = 10; i > 0; i--) {       //倒计时
            try {
                Thread.sleep(1000);//多个线程操作一个对象不安全，用延时来放大问题发生性;每个对象都有一个锁，sleep不会释放锁
                System.out.println(i);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}




public class TestThread {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        MyThread1 threadA1 = new MyThread1("清清");   //创建线程对象
        threadA1.start();                                 //线程对象运行
        new MyThread1("楚楚").start();              //直接创建运行

        MyThread2 threadB1 = new MyThread2("清清");
        MyThread2 threadB2 = new MyThread2("楚楚");
        Thread a1 = new Thread(new MyThread2("清清"));                            //静态代理进线程

        threadA1.setPriority(Thread.MAX_PRIORITY);           //1~10，默认5,优先级高获得CPU调度能力高
        a1.setPriority(1);                                  //先设置优先级再启动
        System.out.println(threadA1.getPriority());        //获取优先级
        a1.start();
        try {                                            //.join()有中断异常（InterruptException），需要抛出
            a1.join();                                  //当a1线程执行结束后才能往下执行，其他线程阻塞
            threadA1.yield();                          //礼让不一定成功
            Thread.State state=a1.getState();         //线程状态 NEW,TIMED_WAITING,RUNNABLE,TERMINATED
            threadA1.setDaemon(true);                //变成守护线程，在用户线程之外跟踪跑，不用等待执行完成
        } catch (InterruptedException ew) {
            System.out.println("中断咯");
        }
        new Thread(threadB2,"名字").start();           //直接代理
        new Thread( ()->System.out.println("") ).start();

        System.out.println("=========================================================================");
        MyThread3 threadC1 = new MyThread3();
        MyThread3 threadC2 = new MyThread3();

        ExecutorService ser = Executors.newFixedThreadPool(2);       //池两个线程
        Future<Boolean> r1 = ser.submit(threadC1);         //ser.submit()时已经执行，有返回值
        Future<Boolean> r2 = ser.submit(threadC2);
        Boolean rb1 = r1.get();
        Boolean rb2 = r2.get();
        System.out.println(rb1 + "," + rb2);
    }


}

class MyThread3 implements Callable {

    @Override
    public Boolean call(){          //可以自己设置返回值
        System.out.println(Thread.currentThread().getName());
        return true;
    }
}