多线程学习（一）

简单多线程小程序代码实现：

1、编写多线程合作逐个字母打印出“I am a programmer”的程序，该字符串有char类型的数组存储

import static jodd.util.ThreadUtil.sleep;

public class CharNum {
     static String str = "i am a programmer";
     String[] str1 = str.split(" ");

     static char[] chars = null;
    static  volatile int len =0;

    public CharNum(){
        StringBuffer sb = new StringBuffer();
        for(int i =0;i< str1.length;i++){

          
            sb.append(str1[i]);

        }
       
        chars = sb.toString().toCharArray();
        len =  chars.length-1;
    }


     public  synchronized  void thread1(){

         new Thread(new Runnable() {
             @Override
             public void run() {

                 while(len>=0){
                     synchronized ("oo"){//给多线程添加一个同步锁
                         if(len>=0){
                             System.out.println("=======1按顺序输出字母========"+chars[len]);
                             len--;
                         }

                     }

                     sleep(1000);

                 }

             }
         }).start();



     }

    public  synchronized  void thread2() {

        new Thread(new Runnable() {
            @Override
            public void run() {

                while (len >= 0) {
                    synchronized ("oo") {//给多线程添加一个同步锁
                        if (len >= 0) {
                            System.out.println("=======2按顺序输出字母========" + chars[len]);
                            len--;
                        }

                    }

                    sleep(1000);

                }

            }
        }).start();

    }

     public static void main(String[] args){
        // CharNum cn = new CharNum();
        // System.out.println("================="+chars.length);

        CharNum cn = new CharNum();
         cn.thread1();
         cn.thread2();


     }



}

3.龟兔赛跑问题
龟兔赛跑：2000米
要求：
    (1)兔子每 0.1 秒 5 米的速度，每跑20米休息1秒;
    (2)乌龟每 0.1 秒跑 2 米，不休息；
    (3)其中一个跑到终点后另一个不跑了！
程序设计思路：
    (1)创建一个Animal动物类，继承Thread，编写一个running抽象方法，重写run方法，把running方法在run方法里面调用。
    (2)创建Rabbit兔子类和Tortoise乌龟类，继承动物类
    (3)两个子类重写running方法
    (4)本题的第3个要求涉及到线程回调。需要在动物类创建一个回调接口，创建一个回调对象。

（一）创建Animal动物类

package com.Animal;

public abstract class Animal extends Thread{

    public int length = 200;


    public abstract void running();


    public void run (){
        super.run();
        while(length>0){

            running();
        }
    }

    //在需要回掉函数的地方申明一个接口

    public static interface Calltoback{
        public void  win();
    }


    //创建接口对象
    public Calltoback calltoback;

}

(二) 创建兔子对象

package com.Animal;


public class Rabbit extends Animal {

    public Rabbit(){

        setName("兔子");
    }


    @Override
    public void running() {
        //兔子的速度
        int speet  = 5;
        length -=speet;

        System.out.println("兔子跑了"+speet+"米，距离终点还有"+length+"米的距离");

        if(length<=0){

            length = 0;
            System.out.println("兔子获得了胜利");
            //给回调函数赋值，让乌龟不要在跑了
            if (calltoback != null){
                 calltoback.win();
            }

        }


            try {
                if((2000-length)%20==0) {         //兔子每跑20米休息1秒
                    this.sleep(1000);
                }else{
                    this.sleep(100);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }


    }
}

（三）创建乌龟对象

package com.Animal;

public class Tortoise extends Animal {

    public Tortoise(){

        this.setName("乌龟");
    }


    @Override
    public void running() {

        int speet = 2;
        length -=speet;

        System.out.println("乌龟已经跑了"+speet+"米，还有"+length+"的距离");

        if(length <= 0){
            length = 0;

            System.out.println("乌龟获得了胜利");
            //让兔子不要再跑了

            if(calltoback!=null){
                calltoback.win();
            }

        }

        try {
            sleep(100);  //每隔0.1秒跑两米
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

（四）创建回调函数对象

package com.Animal;

public class LetOnStop implements Animal.Calltoback {

    Animal an;

    //获取动物对象，可以传入兔子或者乌龟对象

    public LetOnStop(Animal an){
        this.an= an;

    }
    //让动物线程停止
    @Override
    public void win() {
       an.stop();
    }

}

（五）开启多线程

package com.Animal;

public class Test {

    public static void main(String[] args){
        Tortoise tt = new Tortoise();
        Rabbit rb = new Rabbit();

        //回调方法的使用，谁先调用了回调方法，另一个就不在使用了
        LetOnStop ls1 = new LetOnStop(tt);
        //让兔子的回调对象中存在乌龟的值，可以将乌龟停止
        rb.calltoback = ls1;

        LetOnStop ls2 = new LetOnStop(rb);
        tt.calltoback = ls2;

        tt.start();
        rb.start();



    }

}