多线程--------基础

线程：就是进程当中的任务线；
进程：就是正在运行的应用程序
进程是容器，线程依赖进程
一个进程里最少要有一条线程
一条线程太慢
就有了多线程 就是为了提高应用程序对CPU使用率
进程是拥有资源的基本单位，线程是CPU调度的基本单位
JVM虚拟机 至少有两个线程，一个主线程，一个垃圾回收站
并发：多个事件在一个时间段内，高速的切换交替运行
并行：多个事件在一个时间点上同时运行

多线程之间都平级都没钱 所以要相互抢任务赚钱，采用随机的方式执行任务

加入线程:

public final void join ()

    意思就是:
    等待该线程执行完毕了以后, 其他线程才能再次执行
    在线程启动之后, 在调用方法
	可以是线程的并发执行，变为顺序执行（串行）

打断线程的一个阻塞状态

Thread.sleep(2000);
        myThread2.interrupt(); 

开启线程的三种方式，都要使用一个Thread

继承一个Thread类 run（）

//创建线程
        MyThread myThread = new MyThread();
        //开启线程
        // myThread.run(); 这种开启线程的方法错误的做法，这种做法，就是最普通 创建对象调用方法
      /*  void start ()
        使该线程开始执行；Java 虚拟机调用该线程的 run 方法。*/
        myThread.start(); //正确的开启线程
       // 多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。
       // myThread.start(); 同一个线程对象，多次启动会报错
        MyThread myThread1 = new MyThread();
        myThread1.start();

        //上面开启的线程，就会并发的去执行
        public class MyThread extends Thread{
    @Override
    public void run() {
        //一个类中可以定义很多方法，那到底那个方法去需要线程去执行。那我们规定run（）是由线程去执行的
        //一般线程用来处理那些耗时的操作
        //模拟一下耗时操作
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
        }
    }
}

 //获取当前的线程对象
        Thread thread = Thread.currentThread();
        thread.setName("主线程");
        String name = thread.getName();
        System.out.println(name);
        MyThread th1 = new MyThread();
        MyThread th2 = new MyThread();
        //设置线程的名称
        th1.setName("范冰冰");
        th2.setName("李冰冰");

 //可以设置线程的优先级 线程优先级  1---10
        th1.setPriority(Thread.MAX_PRIORITY);//10
        th2.setPriority(Thread.MIN_PRIORITY);//1
        //th3.setPriority(Thread.NORM_PRIORITY);//5
        //获取线程的优先级
        //int priority = th1.getPriority();

实现一个Runable接口 run（）

//创建线程的第二种方式
        //1.定义一个类型，实现Runnable接口
        //2.重新接口种的run方法
        //3，创建接口的子类对象
        //4.创建Thread类对象，把接口的子类对象传递过来
        //5.开启线程
        MyRunnable runable = new MyRunnable();
        Thread thread = new Thread(runable);
        thread.setName("范冰冰");
        thread.start();

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);
        }
    }
}

实现一个callable接口 call（）能抛出异常，有返回值

        实现步骤
        1. 创建一个类实现Callable 接口 重新里面的call()方法
        2. 创建一个FutureTask类将Callable接口的子类对象作为参数传进去
        3. 创建Thread类, 将FutureTask对象作为参数传进去
        4. 开启线程
 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++) {
            //System.out.println(name+"=="+i);
            sum+=i;
        }
        return sum;
    }
}