JAVA学习笔记--进程和线程

进程和线程

进程（Process）

程序是指令和数据的有序集合，本身没有运行的含义，是一个静态的概念。
进程是执行程序的一次执行过程，它是一个动态的概念，是系统资源分配的单位。

线程（Thread）

• 通常在一个进程中可以包括若干个线程，一个进程中至少有一个线程，不然没有存在的意义，线程是CPU调度和执行的单位
• 真正的多线程是指有多个CPU，即多核
• 线程就是独立的执行路径
• 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

线程创建

继承Thread类（重点）

1. 自定义线程类继承Thread类
2. 重写run（）方法，编写线程执行体
3. 创建线程对象，调用start（）方法启动线程
   不建议使用：避免OOP单继承局限性

//创建线程方式一：继承Thread类，重写run（）方法，调用start（）开启线程
public class TestThread1 extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码---"+i);
        }
    }
    public static void main(String[] args) {
        //main线程，主线程
        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();
        //调用start（）方法开启线程
        testThread1.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程"+i);
        }
    }
}

实现Runnable接口（重点）

1. 定义MyRunnable类实现Runnable接口
2. 实现run（）方法，编写线程执行体
3. 创建线程对象，调用start（）方法启动线程
   推荐使用runnable接口，避免单继承的局限性

//创建线程方式2：实现runnable接口，重写run方法，执行线程需要丢入runnab接口实现类，调用start方法
public class TestThread3 implements Runnable{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码---"+i);
        }
    }
    public static void main(String[] args) {
        //创建一个runnable接口的实现类对象
        TestThread3 testThread3 = new TestThread3();
        //创建线程对象，通过线程对象来开启我们的线程，代理
        Thread thread = new Thread(testThread3);
       thread.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程"+i);
        }
    }
}

//模拟龟兔赛跑
public class Race implements Runnable {
   //胜利者
 private static String winner;
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
           //模拟兔子休息
            if (Thread.currentThread().getName().equals("兔子") && i%10==0){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //判断比赛是否结束
            boolean flag = gameOver(i);
            //如果比赛结束了，就停止程序
            if (flag){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步");
        }
    }
     //判断是否完成比赛
    private boolean gameOver(int steps){
       //判断是否有胜利者
        if (winner!=null){//已经存在胜利者了
            return true;
        }{
            if (steps>=100){
                winner = Thread.currentThread().getName();
                System.out.println("winner is "+winner);
                return true;
            }
        }
           return false;
    }
    public static void main(String[] args) {
        Race race = new Race();
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }
}

实现Callable接口（了解）

1. 实现Callable接口，需要返回值类型
2. 重写call方法，需要抛出异常
3. 创建目标对象
4. 创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
5. 提交执行：Future result1 = ser.submit(t1);
6. 获取结果：boolean r1 = result1.get()
7. 关闭服务：ser.shutdownNow();
   好处
8. 可以定义返回值
9. 可以抛出异常

线程停止

//测试stop
//1.建议线程正常停止--->利用次数，不建议死循环
//2.建议使用标注位--->设置一个标志位
//3.不要使用stop或者destroy等过时或者JDK不建议使用的方法
public class TestStop implements Runnable{
    //1.设置一个标识位
    private boolean flag = true;
    @Override
    public void run() {
       int i = 0;
       while (flag){
           System.out.println("run....Thread"+i++);
       }
    }
    //2.设置一个公开的方法停止线程，转换为标志位
    public void stop(){
        this.flag = false;
    }
    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("main"+i);
            if (i==900){
                //调用stop方法切换标志位，让线程停止
                testStop.stop();
                System.out.println("线程该停止了");
            }
        }
    }
}

线程休眠

.sleep()方法

Thread.sleep(1000);

线程礼让

• 礼让线程，让当前正在执行的线程暂停，但不阻塞
• 将线程从运行状态转为就绪状态
• 让CPU重新调度，礼让不一定成功，看CPU心情

//测试礼让线程
//礼让不一定成功，看CPU心情
public class TestYield {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
    }
}
class MyYield implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield();//礼让
        System.out.println(Thread.currentThread().getName()+"线程停止执行");
    }
}

观测线程状态

//观察测试线程状态
public class TestState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("//");
        });
        //观察状态
        Thread.State state = thread.getState();
        System.out.println(state);
        //观察启动后
        thread.start();//启动线程
        state = thread.getState();
        System.out.println(state);
        while (state != Thread.State.TERMINATED){//只要线程不停止，就一直输出状态
            Thread.sleep(100);
            state = thread.getState();//更新线程状态
            System.out.println(state);//输出状态
        }
    }
}

线程同步

并发：同一个对象被多个线程同时操作
形成条件：队列+锁

同步块

synchronized（Obj）{}
Obj称之为同步监视器

• Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
• 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class

线程池

思路

提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的交通工具

好处

• 提高了响应速度（减少了创建新线程的时间）
• 降低了资源消耗（重复利用线程池中线程，不需要每次都创建）
• 便于线程管理

//测试线程池
public class TestPool {
    public static void main(String[] args) {
        //1.创建服务，创建线程池
        //newFixedThreadPool 参数为：线程池大小
        ExecutorService service = Executors.newFixedThreadPool(10);
        //执行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        //2.关闭连接
        service.shutdown();
    }
}
class MyThread implements Runnable{
    @Override
    public void run() {
            System.out.println(Thread.currentThread().getName());
    }
}