61_Java_多线程1_创建_方法

程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一 段静态的代码，静态对象

进程(process)是程序的一次执行过程，有生命周期(自身产生 - 存在 - 消亡过程); 是动态的过程(Linux  ps -ef) 有生命周期(自身产生 - 存在 - 消亡过程)
线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径

Thread类 构造器
  Thread()：创建新的Thread对象
  Thread(String threadname)：创建线程并指定线程实例名
  Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接 口中的run方法
  Thread(Runnable target, String name)：创建新的Thread对象

创建线程的方式
1 继承Thread类的方式  ； 2 实现Runnable接口
3 实现Callable接口； 4 使用线程池

1 继承Thread类的方式 
2 实现Runnable接口  - new thread( Runnable r1)  创建线程实例

public class ThreadOverrideTest {
    public static void main(String[] args) {

       MyThread1 myThread1 = new MyThread1();
        myThread1.start();
        
        Mythread2 mythread2 = new Mythread2();
        Thread thread2 = new Thread(mythread2);
        thread2.start();
    }
}

class MyThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <=100 ; i++) {
            if (i %2 ==0){
                System.out.println(Thread.currentThread().getName() + ":"+ i);
            }
        }
    }
}

class Mythread2 implements  Runnable{

    @Override
    public void run() {
        for (int i = 0; i <=100 ; i++) {
            if (i %2 !=0){
                System.out.println(Thread.currentThread().getName() + ":"+ i);
            }
        }
    }
}

3 实现Callable接口
  相比run()方法，可以有返回值 
   方法可以抛出异常 
   支持泛型的返回值 
   需要借助FutureTask类,比如获取返回结果

Future接口  
可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等
FutrueTask是Futrue接口的唯一的实现类  
FutureTask同时实现了Runnable, Future接口,既可以作为Runnable被线程执行, 又可以作为Future得到Callable的返回值

public class ThreadOverideTest2 {
    public static void main(String[] args) {

        ////3.创建Callable接口实现类的对象
        Mythread3 mythread3 = new Mythread3();

        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象

        FutureTask futureTask = new FutureTask(mythread3);


        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        Thread t1 = new Thread(futureTask);

        t1.start();

        try {
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}


// 1.创建一个实现Callable的实现类
class Mythread3 implements Callable {
//2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 0; i <=100 ; i++) {
            if (i %2 ==0){
                sum += i;
            }
        }
        return sum;
    }
}

4 使用线程池 经常创建和销毁、使用量特别大的资源，比如并发情况下的线程， 对性能影响很大
ExecutorService 和 Executors 
ExecutorService --> 接收 ;  Executors --> 创建
ExecutorService：真正的线程池接口, 常见子类ThreadPoolExecutor 

 Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池 
 Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池 
 Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池  
 Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池  
 Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运 行命令或者定期地执行。

public class ThreadOverrideTest3 {
    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        //ExecutorService 是个接口，多态体现，service是个实现类的对象
        ExecutorService service = Executors.newFixedThreadPool(10);
        // System.out.println(service.getClass()); // ThreadPoolExecutor
        // service是接口，需要用service实现类的对象
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        // service1.setCorePoolSize(15);
        // service1.setKeepAliveTime();

        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new myThread4());//适合适用于Runnable
        service.execute(new myThread4());//适合适用于Runnable

//        service.submit(Callable callable);//适合使用于Callable
        //3.关闭连接池
        service.shutdown();
    }
}

class myThread4 implements Runnable{
    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

测试Thread中的常用方法：
1. start():启动当前线程；调用当前线程的run()
2. run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
3. currentThread():静态方法，返回执行当前代码的线程
4. getName():获取当前线程的名字
5. setName():设置当前线程的名字
6. yield():释放当前cpu的执行权
7. join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
8. stop():已过时。当执行此方法时，强制结束当前线程。
9. sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。
10. isAlive():判断当前线程是否存活

线程的优先级：
1. 优先级设置
  MAX_PRIORITY：10
  MIN _PRIORITY：1
  NORM_PRIORITY：5  -->默认优先级
2.如何获取和设置当前线程的优先级：
   getPriority():获取线程的优先级
   setPriority(int p):设置线程的优先级
说明：高优先级的线程要抢占低优先级线程cpu的执行权。只是从概率上讲，高优先级的线程高概率的情况下被执行。
并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行

class HelloThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
//                try {
//                    sleep(10);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }

                System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority() + ":" + i);
            }
//            if(i % 20 == 0){
//                yield();
//            }
        }
    }
    public HelloThread(String name){
        super(name);
    }
}

public class ThreadMethodTest {
    public static void main(String[] args) {
        HelloThread h1 = new HelloThread("Thread：1");
//        h1.setName("线程一");
        //设置分线程的优先级
        h1.setPriority(Thread.MAX_PRIORITY);
        h1.start();

        //给主线程命名
        Thread.currentThread().setName("主线程");
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority() + ":" + i);
            }
//            if(i == 20){
//                try {
//                    h1.join();
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//            }
        }
//        System.out.println(h1.isAlive());
    }
}