线程(线程与进程篇)

线程的概念

什么是进程?

打开任务管理器会看到许多的进程,进程是(磁盘,内存,cpu)的最小单位,进程与进程之间是相互独立的,有自己的内存空间.就是正在执行的程序。

什么是线程？

线程是进程中执行运算的最小单位，也是CPU资源分配的最小单元，如果把一个进程比作一个任务的话，那线程就是其中一个子任务，进程包含一个或多个线程。线程需要的资源很少，线程可以共享进程中的资源，相互的通信也会更加的方便。

串行、并行和并发

买饭时会排着队在窗口买食物

如果把排队的人比作一个指令，窗口比作cpu的话  那么

串行就是排成一队在一个窗口买食物

并行就是排成多队在一个窗口买食物

并发就是排成多队在多个窗口买食物

线程的实现

Java几种实现线程的方式

1. 继承Thread类  

1. 继承Thread类

2. 重写run方法

3. 调用start启动线

public class MyTreadTest{
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
//        myThread.run();
//        调用start启动线
        myThread.start();
        for (int i = 0; i < 50; i++) {
            System.out.println(Thread.currentThread().getName() + "执行了" + i);
        }
    }

}
//继承Thread类
 class MyThread extends Thread{
//    重写run方法
    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println(Thread.currentThread().getName() + "执行了" + i);
        }
    }
}

 run()方法和start()方法的区别：

最主要的区别就是run()方法没有启动新的线程，start()启动了新的线程

2.实现Runnable接口

1. 实现Runnable接口

2. 实现run方法

3. 创建实现Runnable接口的对象，传入Thread对象中

4. 启动线程

public class RunnableDemo {
    public static void main(String[] args) {
//        用lammaba表达式 实现Runnable接口和实现run方法  创建实现Runnable接口的对象，传入Thread对象中
        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName()+"执行了"+i);
            }
            }).start();//启动线程
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"执行了"+i);
        }
    }
}

3.实现Callable接口

实现Callable接口可以返回值，继承Thread类和Runnable不行

1. 实现Callable接口，实现call方法

2. 创建Callable对象，传入FutureTask对象

3. 创建FutureTask对象，传入Thread对象

4. 启动线程

5. 调用get方法得到返回结果

//实现Callable接口，实现call方法
class MyCallable implements Callable<Long> {
    @Override
    public Long call() throws Exception {
        long sum=0;
        for (long i = 0; i < 100000000000L; i++) {
            sum+=i;
        }
        return sum;
    }
}

public class CallableDemo  {
    public static void main(String[] args) {
        System.out.println(System.currentTimeMillis());
//        创建Callable对象，传入FutureTask对象
        FutureTask<Long> longFutureTask = new FutureTask<>(new MyCallable());
//        创建FutureTask对象，传入Thread对象
        Thread thread = new Thread(longFutureTask);
//        启动线程
        thread.start();
        try {
//            调用get方法得到返回结果
            System.out.println(longFutureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

4.使用线程池

线程的生命周期

 

NEW           Thread thread=new Thread()  线程的创建

Runnable   thread.start() 调用方法后，线程处于就绪状态

Running   各个线程之间会抢占cpu，抢占到CPU后状态会变成running状态

Blocking   当线程出现sleep睡眠，执行IO操作，wait等待，suspend挂起时状态会改变成blocking

Dead           当线程run()方法执行完，stop（不建议使用）时线程会结束生命周期

线程的常用方法

方法	介绍
start()	启动
stop()	停止（禁用，可能导致线程死锁等问题），停止线程可以让run执行结束
String getName()	获得线程的名字
setName(String)	设置线程名字
sleep(long)	进入睡眠，毫秒
setPriority(int)	设置线程的优先级（1~10从低到高）越高抢CPU几率更高
setDaemon(boolean)	设置为后台线程 true ,后台线程是为其它线程服务的，如果没有其它线程存在，就自动死亡；使用案例：GC就是一种后台线程
join()	线程的加入（合并）让其它线程先执行完，再执行自己的指令