进程与线程（一）基础

public class MyThread extends Thread {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"---->"+i);
        }
    }

    public static void main(String[] args) {
        //创建线程对象
        MyThread thread1 = new MyThread();
        //启动线程
        thread1.start();
        //主线程执行
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"---->"+i);
        }
    }
}

（2）实现Runnable接口

1.定义类实现Runnable接口

2.实现run方法

3.创建Thread对象，传入Runnable对象，调用start

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"--->"+i);
        }
    }

    public static void main(String[] args) {
        //创建Runnable对象 创建Thread对象
        Thread thread1 = new Thread(new MyRunnable());
        //启动线程
        thread1.start();
        //匿名内部类
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println(Thread.currentThread().getName()+"--->"+i);
                }
            }
        });
        thread2.start();
        //lambda表达式
        Thread thread3 = new Thread(()->{
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName()+"--->"+i);
            }
        });
        thread3.start();
    }
}

（3）实现Callable接口

前面两种方式都实现的run方法没有返回值，如果需要进行运算后返回值，就需要使用Callable接口

1.实现Callable接口的call方法

2.创建FutureTask对象传入Callable实现对象

3.创建Thread线程传入FutureTask对象

4.启动线程

5.通过FutureTask的get方法获得返回值

public class MyCallable implements Callable<Long> {

    @Override
    public Long call() throws Exception {
        long sum = 0;
        for(int i = 0;i < 10000000;i++){
            sum += i;
        }
        return sum;
    }

    public static void main(String[] args) {
        //创建FutureTask对象，传入Callable对象
        FutureTask<Long> futureTask = new FutureTask<>(new MyCallable());
        //创建Thread对象
        Thread thread = new Thread(futureTask);
        //启动线程
        thread.start();
        //获得返回值
        try {
            Long value = futureTask.get();
            System.out.println("运算结果是：" + value);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

5.线程的生命周期

线程的生命周期（状态）分为：

1.新建 2.就绪/准备 3.运行 4.阻塞 5.死亡

6.线程的常用方法

start() 启动线程
stop() 停止线程
setName(String) 设置名字
getName() 获得名字
sleep(long) 睡眠
suspend() 挂起线程
resume() 恢复线程
yield() 放弃执行
join() 合并线程
setPriority(int) 设置线程优先级
setDaemon(boolean) 设置后台线程

7.停止线程

stop() 调用stop会停止线程，不会释放锁，可能导致死锁，禁用stop
等待run执行完
在run执行代码中加入条件，中途停止执行

8.线程的优先级

线程有优先级从低到高分为1~10，默认是5

线程优先级越高抢到CPU的几率越高

可以给执行更重要任务的线程设置更高的优先级

        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + "-->" + i);
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + "-->" + i);
            }
        });
        //设置优先级
        thread2.setPriority(Thread.MAX_PRIORITY);
        thread1.setPriority(Thread.MIN_PRIORITY);
        thread1.start();
        thread2.start();