进程与线程，只看这一篇就够了

一、程序和进程的区别 ？

• 程序是一种静态概念，是保存在磁盘上的一系列文件

• 进程是一种动态概念，是运行中的程序，一个程序包括一个或多个进程

1、进程和线程的区别 线程

线程是CPU资源分配的最小单元

线程需要的资源更少，可以看做是一种轻量级的进程

线程会共享进程中的内存，线程也有独立的空间（栈、程序计数器）

线程相互通信更加方便

进程

进程是程序执行相关资源（CPU、内存、磁盘等）分配的最小单元

进程是一系列线程的集合

进程之间是相互独立的，有自己的内存空间

2、串行和并发

1、串行：多个指令依次执行

2、并行：多个CPU内核同时执行多个线程，线程是同时执行的

3、并发：每个线程单独执行一段指令，一个cpu在线程间切换（并不是同时执行）

二、线程的实现方式 1、继承Thread类

1. 继承Thread类

2. 重写run方法

3. 调用start启动线程

class MyThread extends Thread{

    
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() +"执行了" + i);
        }
    }
}

public class ThreadDemo {

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

2、实现Runnable接口

1. 实现Runnable接口

2. 实现run方法

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

class MyRunnable implements Runnable{

    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "--" + i);
        }
    }
}
public class RunnableDemo {
    public static void main(String[] args) {
        //创建Runnable对象，传入Thread对象
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        //启动线程
        thread.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表达式
        new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + "--" + i);
            }
        }).start();
    }
}

3、实现Callable接口

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

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

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

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

4. 启动线程

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

class MyCallable implements Callable {

    @Override
    public Long call() throws Exception {
        //模拟复杂运算
        long sum = 0;
        for(long i = 0;i < 1000000000L;i++){
            sum += i;
        }
        return sum;
    }
}
public class CallableDemo {

    public static void main(String[] args) {
        //创建Callable对象，传入FutureTask对象
        FutureTask task = new FutureTask<>(new MyCallable());
        //创建FutureTask对象到Thread对象中
        Thread thread = new Thread(task);
        //启动线程
        thread.start();
        System.out.println("-----等待结果-----");
        //获得返回值
        try {
            System.out.println(task.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

三、注意！！！ 线程的run和start的区别

• run没有启动新线程，在主线程中执行

• start才能启动新线程

继承Thread和实现Runnable的区别

• 继承Thread类，不能继承其它的类，语法有限制

• 实现Runnable接口，可以继承其它类，语法没有限制

• Runnalbe接口强制要求实现run方法，不容易出现错误

四、线程的生命周期

• 新建 NEW

• 准备/就绪 START

• 运行 RUNNING

• 阻塞 BLOCKING

• 死亡 DEAD

线程的常用方法

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

五：练习         1、设计两个线程，一个线程负责打印1~１０0以内所有的偶数；然后，另外一个线程负责打印1~１０0以内所有的奇数。

package com.hopu.test;

class d1 implements Runnable{
    @Override
    public void run() {
        for (int i = 1; i <=100 ; i++) {
            if (i%2==0){
                if (i==100){
                    System.out.println(i);
                }else if (i==2){
                    System.out.print("偶数:"+i+",");
                } else {
                    System.out.print(i+",");
                }
            }
        }
    }
}

class d2 implements Runnable{
    @Override
    public void run() {
        for (int i = 1; i <=100 ; i++) {
            if (i%2==1){
                if (i==99){
                    System.out.println(i);
                }else if (i==1){
                    System.out.print("奇数:"+i+",");
                } else {
                    System.out.print(i+",");
                }
            }
        }
    }
}

public class demo1 {
    public static void main(String[] args) {
        d1 d1 = new d1();
        d2 d2 = new d2();
        Thread thread1 = new Thread(d1);
        Thread thread2 = new Thread(d2);
        thread1.setPriority(Thread.MIN_PRIORITY);
        thread2.setPriority(Thread.MAX_PRIORITY);
        thread2.start();
        thread1.start();


    }
}

                 2、实现一个线程，用于扫描某个目录下的所有文本文件（包括：java、txt、html），并将文字内容打印出来。

package com.hopu.test;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;

public class demo2 {
    public static void main(String[] args) {
        new Thread(() -> {
            File file = new File("D:\新建文件夹\PetShop");
            readFile(file);
        }).start();

    }

    public static void readFile(File f) {
        if (f.isDirectory()) {
            File[] files = f.listFiles();
            if (files != null) {
                for (File file : files) {
                    readFile(file);
                }
            }
        } else {
            System.out.println(f.getName());
            //读文件
            try {
                //得到文件
                //得到文件读取的字符流
                FileReader fileReader = new FileReader(f);
                //得到带缓冲字符流
                BufferedReader bufferedReader = new BufferedReader(fileReader);
                String readLine = null;
                while ((readLine = bufferedReader.readLine()) != null) {
                    System.out.println(readLine);
                }
                //字节流
                fileReader.close();
                bufferedReader.close();
            } catch (Exception e) {
                e.printStackTrace();
            }

        }

    }

}

        3、某人正在看电视连续剧，从第1~88集，看到第10集时，来了一个送快递的，收完快递后后，继续看电视。

package com.hopu.test;


class test implements Runnable{
    @Override
    public void run() {
        for (int i = 1; i <=88 ; i++) {
            System.out.println("我正在看第"+i+"集电视剧");
        }
    }
}

class test2 implements Runnable{

    @Override
    public void run() {
        System.out.println("---------收快递--------");
    }
}
public class demo3 {
    public static void main(String[] args) {
        test test = new test();
        test2 test2 = new test2();
        Thread thread = new Thread(test2);
        Thread thread1 = new Thread(()->{
            for (int i=1;i<=88;i++){
                if(i==10){
                    try {
                        thread.setPriority(Thread.MAX_PRIORITY);
                        thread.start();
                        System.out.println("我正在看第"+i+"集电视剧");
                        thread.join();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else {
                    System.out.println("我正在看第"+i+"集电视剧");
                }
            }
        });
//        Thread thread2 = new Thread(test2);

        thread1.start();

    }
}

        4、多线程模拟龟兔赛跑：乌龟和兔子进行1000米赛跑，兔子前进5米，乌龟只能前进1米。但兔子每20米要休息500毫秒，而乌龟是每100米休息500毫秒。谁先到终点就结束程序，并显示获胜方

package com.hopu.test;


class Rabbit implements Runnable{
    @Override
    public void run() {
        for (int i = 5; i <=1000; i+=5) {
            System.out.println("兔子前进5米,兔子一共跑了"+i+"米！");
            if(i==1000) {
                System.out.println("比赛结束！兔子胜利");
                System.exit(0);
            }
            if(i%20==0) {
                try {
                    System.out.println("兔子共跑了"+i+"米,休息500毫秒！");
                    Thread.sleep(500);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

    }

}

class Tortoise implements Runnable{
    @Override
    public void run() {
        for (int i = 1; i <=1000; i++) {
            System.out.println("乌龟前进1米,乌龟共跑了"+i+"米！");
            if(i==1000) {
                System.out.println("比赛结束！乌龟胜利");
                System.exit(0);
            }
            if(i%100==0) {
                try {
                    System.out.println("乌龟共跑了"+i+"米,休息500毫秒！");
                    Thread.sleep(500);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

    }
}
public class demo4 {
    public static void main(String[] args) {
        Rabbit rabbit = new Rabbit();
        Thread thread1=new Thread(rabbit);
        Tortoise tortoise = new Tortoise();
        Thread thread2=new Thread(tortoise);
        System.out.println("比赛开始！");
        thread1.start();
        thread2.start();
    }

}