Process（进程）与Thread（线程）

• 说起进程，就不得不说下程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
• 而进程则是执行程序的一次执行过程，它是一个动态的概念，是系统资源分配的单位
• 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位

注意:很多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就会有同时执行的错局

线程的创建（Thread Rannable Callable）

Thread

• 自定义线程类继承Thread类
• 重新run（）方法编写线程执行体
• 创建线程对象，调用start（）方法启动线程

创建线程方式一：继承Thread类，重写run方法，调用start开启线程

public class TestThread1 extends Thread{
    //继承Thread 重写run方法
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 2000; i++) {
            System.out.println("重写run方法0----"+i);
        }
    }
    //main线程主线程
    public static void main(String[] args) {
        //创建一个线程对象
        TestThread1 testThread1=new TestThread1();
        //调用start开启线程
        testThread1.start();
        
        //testThread1.run();
        for (int i = 0; i < 2000; i++) {
            System.out.println("main主线程----"+i);
        }
    }
}

总结：注意线程开启不一定立即执行,由CPU调度安排
调用start开启新的线程执行
调用run只有一条主线程依次执行

Rannable

• 定义MyRannable类实现Rannable接口
• 实现run（）方法，编写线程执行体
• 创建线程对象，调用start（）方法启动线程

public class TestThread3Runnable implements Runnable {
    //实现Runnable方法run
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("继承Runnable----"+i);
        }
    }
    //主方法
    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        TestThread3Runnable runnable=new TestThread3Runnable();
        //创建线程对象，通过线程对象开启我们的线程，（代理）
//        Thread thread=new Thread(runnable);
//        thread.start();
        //可简写为如下
        new Thread(runnable).run();
        for (int i = 0; i < 1000; i++) {
            System.out.println("主方法****"+i);
        }
    }
}

小结

• 继承Thread类
  • 子类继承Thread类具备多线程能力
  • 启动线程：子类对象.start()
  • 不建议使用：避免OOP单继承的局限性
• 实现Runnable接口
  • 实现接口Runnable具有多线程能力
  • 启动线程：传入目标对象+Thread对象.start（）
  • 推荐使用：避免单继承局限性，灵活方便同一个对象被多个线程使用

//一份资源
 TestThread3Runnable runnable=new TestThread3Runnable();
        //多个代理
        new Thread(runnable,"AA").run();
        new Thread(runnable,"BB").run();
        new Thread(runnable,"CC").run();

多线程06：初识多并发问题

案例
多线程(mutilthreading)操作同一个对象
异常：多个线程操作同一个对象发现问题，线程不安全，数据紊乱

public class TicketCase implements Runnable{
    //Case ticket
    //scramble for ticket
    private  int ticketNumber=10;
    @Override
    public void run() {
        while (true){
            if (ticketNumber<=0){
                break;
            }
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName()+"---->买到了第---->"+ticketNumber--+"票");
        }
    }
    public static void main(String[] args) {
        TicketCase ticketCase=new TicketCase();
        new Thread(ticketCase,"AAA").start();
        new Thread(ticketCase,"BBB").start();
        new Thread(ticketCase,"CCC").start();
    }
}

多线程：07Case Race龟兔赛跑案例

//实现龟兔赛跑
public class Race implements Runnable{
    private static String winner;//胜利
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            boolean iswinner = judgeGame(i);
            if (iswinner){
                break;
            }
            //判断比赛是否结束
            System.out.println(Thread.currentThread().getName()+"：已经跑了"+i+"步");
        }
    }
    //跑步方法
    public boolean judgeGame(int i){
        if (winner!=null){//判断是否100 直接结束游戏
            return true;
        }else {
            if (i>=100){
                winner=Thread.currentThread().getName();
                System.out.println(Thread.currentThread().getName()+"---->已经胜利了---->"+i);
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        Race race=new Race();
        new Thread(race,"AAAAA").start();
        new Thread(race,"CCCCC").start();
    }
}