并发 如何创建线程 多线程

进程：一个程序的执行过程

线程：一个方法就是一个线程 执行路径 

多线程是同时运行的

并发：多个线程抢夺一个资源 操作同一个对象

 创建线程方法1

//创建线程方法1  继承Thread类 重写润方法 调用start开启线程
public class TestThead extends Thread{
    @Override
    public void run() {
        super.run();
 //模拟延迟
        Thread.sleep(1000);
    }
    //main线程 主线程
    public static void main(String[] args) {
        //创建一个线程对象
        TestThead t1=new TestThead();
        //调用start方法开启线程
        t1.start();

    }
}

创建线程方法2

//创建线程方2 继承Runnable接口实现run方法
public class TestThead implements Runnable{
    @Override
    public void run() {
        for(int i=1;i<1000;i++){
            System.out.println("我是小猫");
        }

    }
    //main线程 主线程
    public static void main(String[] args) {
        //创建一个Runnable接口的实现类对象
        TestThead t1=new TestThead();
       // 创建线程对象 通过现成对象来开启线程
        Thread thead=new Thread(t1);
        thead.start();
        for(int i=1;i<1000;i++){
            System.out.println("喵喵");
        }
    }
}

//多个线程同时操纵一个对象 县城不安全 数据紊乱
public class test2 implements Runnable {
    private  int ticket =10;
    public static void main(String[] args) {
        test2 t2=new test2();
        //多个线程操纵一个数据 就会产生并发
        Thread s1=new Thread(t2,"小红");
        Thread s2=new Thread(t2,"小就");
        Thread s3=new Thread(t2,"小个");
        s1.start();
        s2.start();
        s3.start();
    }

    @Override
    public void run() {
        while(true){
            if(ticket<=0){
                break;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            int k=ticket--;
            System.out.println(Thread.currentThread().getName()+"拿到了第"+k+"几张票");
        }

    }
}

结果展示

龟兔赛跑

public class GuTU implements Runnable{
     static String winner;

     boolean gameover(int step){
         if(step>=100){
             winner=Thread.currentThread().getName();
             System.out.println("胜者是"+winner);
             return true;
         }
        return false;
     }
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if(Thread.currentThread().getName().equals("兔子")){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            boolean flage=gameover(i);
            if(flage){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"走了"+i);
        }
    }

    public static void main(String[] args) {
         GuTU g1=new GuTU();
         Thread th=new Thread(g1,"乌龟");
        Thread th2=new Thread(g1,"兔子");
        th.start();
        th2.start();
    }

}

结果i

如何另一个线程停止

    boolean glag=true;
    //设置一个标记位
    public static void main(String[] args) {
        Test te=new Test();
        Thread s=new Thread(te);
        s.start();
        
        for (int i = 0; i < 1000; i++) {
            //System.out.println(i);
            if(i==600){
                //调用停止方法
                te.st();
                System.out.println("该停止了");
            }
        }
    }
    @Override
    public void run() {
        while (glag){
            System.out.println("这是Thead未被停止");
        }
    }
    //设置一个方法转换标志位
    public  void st(){
        this.glag=false;
    }
}

sleep的使用 网络延时 就在自己的要执行的方法里 加入就可以了

public class Test{
    public static void main(String[] args) throws InterruptedException {
        run();
    }
    public static void run() throws InterruptedException {
        int num=10;
        while (true){

            Thread.sleep(1000);
            System.out.println(num--);
            if(num<0){
                break;
            }
        }
    }
}

yield() 礼让线程让当前的线程停止但不阻塞线程  礼让不一定成功