多线程（一） 创建多线程+线程常用方法

理解Runnable和Thread的区别：https://blog.csdn.net/zhaojianting/article/details/9766437

---

多线程即在同一时间，可以做多件事情。
创建多线程有3种方式，分别是继承线程类,实现Runnable接口,匿名类

---

• 启动一个线程

线程有三种创建方法：
1.继承Thread类的方式
    public class Testthread extends Thread{
        public void run(){
            //
        }
    }

run方法里面就是写你这个线程要做的事情。

然后：

    TestThread t1=new TestThread();
    t1.start();

通过.start()方法就可以开始t1这个线程啦！

 
2.实现Runnable的方式

    public class ttt implements Runnable{
         
        public void run(){
            
        }
    }

然后：

    ttt t2 = new ttt();
             
    new Thread(t2).start();

就可以开始t2这个线程啦，需要注意的同样也是要有.start(）才能运行这个线程。

3.匿名类的方式
这也是我喜欢的方式，因为写起来方便

    Thread t3 = new Thread() {
        public void run()
        {
            //
        }
    };
同样的要注意：启动线程是start()方法，run()并不能启动一个新的线程。

package UML;
/*
 *多线程即在同一时间，可以做多件事情。
 *创建多线程有3种方式，分别是继承线程类,实现Runnable接口,匿名类
 *线程的概念：首先要理解进程(Processor)和线程(Thread)的区别
                进程：启动一个LOL.exe就叫一个进程。 接着又启动一个DOTA.exe，这叫两个进程。
                线程：线程是在进程内部同时做的事情，比如在LOL里，有很多事情要同时做，比如"盖伦” 击杀“提莫”，同时“赏金猎人”又在击杀“盲僧”，这就是由多线程来实现的。
*/
public class TestThread {

    public static void main(String[] args) {
        
        Hero gareen = new Hero();
        gareen.name = "盖伦";
        gareen.hp = 616;
        gareen.damage = 50;
 
        Hero teemo = new Hero();
        teemo.name = "提莫";
        teemo.hp = 300;
        teemo.damage = 30;
         
        Hero bh = new Hero();
        bh.name = "赏金猎人";
        bh.hp = 500;
        bh.damage = 65;
         
        Hero leesin = new Hero();
        leesin.name = "盲僧";
        leesin.hp = 455;
        leesin.damage = 80;
        
        //方法1 创建多线程-继承线程类 
        /*使用多线程，就可以做到盖伦在攻击提莫的同时，赏金猎人也在攻击盲僧设计一个类KillThread 继承Thread，并且重写run方法启动线程办法： 实例化一个KillThread对象，并且调用其start方法就可以观察到 赏金猎人攻击盲僧的同时，盖伦也在攻击提莫 
        KillThread killThread1=new KillThread(gareen,teemo);
        killThread1.start();
        KillThread killThread2 = new KillThread(bh,leesin);
        killThread2.start();*/
        
         //方法2 创建多线程-实现Runnable接口 
        /*创建类Battle，实现Runnable接口。启动的时候，首先创建一个Battle对象，然后再根据该battle对象创建一个线程对象，并启动
        Battle b1=new Battle(gareen,teemo);//b1 对象实现了Runnable接口，所以有run方法，但是直接调用run方法，并不会启动一个新的线程。
        new Thread(b1).start();//必须借助一个线程对象的start()方法，才会启动一个新的线程，这个线程启动的时候，就会去执行b1.run()方法
        Battle b2=new Battle(bh,leesin);
        new Thread(b2).start();*/
        
        /*方法3 创建多线程-匿名类 
         *  使用匿名类，继承Thread,重写run方法，直接在run方法中写业务代码
         *  匿名类的一个好处是可以很方便的访问外部的局部变量。
         *  前提是外部的局部变量需要被声明为final。(JDK7以后就不需要了) */
        Thread t1=new Thread() {
            public void run() {
                while(!teemo.isDead()) {
                    gareen.attackHero(teemo);
                }
            }
        };
        t1.start();
   
        Thread t2=new Thread() {
            public void run() {
                while(!teemo.isDead()) {
                    bh.attackHero(leesin);
                }
            }
        };
        t2.start();
    }
}

package UML;

public class KillThread extends Thread {
    private Hero h1;
    private Hero h2;
 
    public KillThread(Hero h1, Hero h2){
        this.h1 = h1;
        this.h2 = h2;
    }
 
    public void run(){
        while(!h2.isDead()){
            h1.attackHero(h2);
        }
    }
}

package UML;

public class Battle implements Runnable {
    
    private Hero h1;
    private Hero h2;
    public Battle(Hero h1,Hero h2) {
        this.h1=h1;
        this.h2=h2;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        while(!h2.isDead()) {
            h1.attackHero(h2);
        }

    }

}

package UML;
import java.util.*;
public class Hero implements Comparable<Hero>{
    public String name;
    public float hp;
    public int damage;
    public Hero() {
    }
    // 增加一个初始化name的构造方法
    public Hero(String name) {
 
        this.name = name;
    }
    // 重写toString方法
    public String toString() {
        //return String.format("[name:%s hp:%.0f damage:%.0f]%n", name,hp,damage);
        return "Hero [name=" + name + ", hp=" + hp + ", damage=" + damage + "]
";
    }
    public Hero(String name,int hp,int damage) {
        this.name=name;
        this.hp=hp;
        this.damage=damage;
    }
    @Override
    public int compareTo(Hero anotherHero) {
        if(damage<anotherHero.damage)
            return 1; 
        else
            return -1;
    }
    public void attackHero(Hero h) {
        try {
            Thread.sleep(1000);
        }catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        h.hp-=damage;
        System.out.format("%s is attacking %s,%s'blood now is %.0f%n",name,h.name,h.name,h.hp);
        if(h.isDead())
            System.out.println(h.name +"死了！");
    }
    public boolean isDead() {
        return 0>=hp?true:false;
    }
}

---

• 线程常用方法

1、暂停当前线程： .sleep()
顾名思义，把当前的线程暂停一定时间，其他的线程并不会受到影响。
注意是会抛出interruptedException异常的。

2、加入到当前线程中： .join()
join的作用是当这个线程运行完事儿之后程序才继续往下走，不然会一直停在join方法处。
            使用场景：如果在某处后边的处理需要使用到t1的数据，那么可以用join来等待t1线程执行结束。

3、定义线程的优先级： .setPriority()
当线程处于竞争关系的时候，优先级高的线程会获得更多的cup资源，也就是这个线程会执行得更快

4、临时暂停： .yield
并不是直接就给它停住了，而是它自己也在慢慢运行，但是会把更多的cup资源让给其他的线程。

5、守护线程： .setDaemon(true)
守护线程的概念是： 当一个进程里，所有的线程都是守护线程的时候，结束当前进程。
就是说可以用来把一些辅助线程写成守护的，那么当干实事的线程完事了，这些守护的线程就没必要继续了。
比如写日志啊，性能统计等。

package UML;

import java.util.*;

public class TestThread1 {
    /*当前线程暂停
      Thread.sleep(1000); 表示当前线程暂停1000毫秒 ，其他线程不受影响
      Thread.sleep(1000); 会抛出InterruptedException 中断异常，因为当前线程sleep的时候，
        有可能被停止，这时就会抛出 InterruptedException */
    public static void example1() {
        Thread t1=new Thread() {
            public void run() {
                int seconds=0;
                while(true) {
                    try {
                        Thread.sleep(1000);
                    }catch(InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.printf("已经玩了LOL %d 秒%n", seconds++);
                }
            }
        };
        t1.start();
    }
    
    /*所有进程，至少会有一个线程即主线程，即main方法开始执行，就会有一个看不见的主线程存在。
        在42行执行t.join，即表明在主线程中加入该线程。
        主线程会等待该线程结束完毕， 才会往下运行。 */
    public static void example2() {
        final Hero gareen = new Hero();
        gareen.name = "盖伦";
        gareen.hp = 616;
        gareen.damage = 50;
  
        final Hero teemo = new Hero();
        teemo.name = "提莫";
        teemo.hp = 300;
        teemo.damage = 30;
          
        final Hero bh = new Hero();
        bh.name = "赏金猎人";
        bh.hp = 500;
        bh.damage = 65;
          
        final Hero leesin = new Hero();
        leesin.name = "盲僧";
        leesin.hp = 455;
        leesin.damage = 80;
          
        Thread t1= new Thread(){
            public void run(){
                while(!teemo.isDead()){
                    gareen.attackHero(teemo);
                }              
            }
        };
          
        t1.start();
        //代码执行到这里，一直是main线程在运行
        try {
            //t1线程加入到main线程中来，只有t1线程运行结束，才会继续往下走
            t1.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
 
        Thread t2= new Thread(){
            public void run(){
                while(!leesin.isDead()){
                    bh.attackHero(leesin);
                }              
            }
        };
        //会观察到盖伦把提莫杀掉后，才运行t2线程
        t2.start();
    }
    
    /* 线程优先级 
     * 当线程处于竞争关系的时候，优先级高的线程会有更大的几率获得CPU资源
           为了演示该效果，要把暂停时间去掉，多条线程各自会尽力去占有CPU资源
       同时把英雄的血量增加100倍，攻击减低到1，才有足够的时间观察到优先级的演示
       如图可见，线程1的优先级是MAX_PRIORITY，所以它争取到了更多的CPU资源执行代码 
     */
    public static void example3() {
        final Hero gareen = new Hero();
        gareen.name = "盖伦";
        gareen.hp = 6160;
        gareen.damage = 1;
  
        final Hero teemo = new Hero();
        teemo.name = "提莫";
        teemo.hp = 3000;
        teemo.damage = 1;
          
        final Hero bh = new Hero();
        bh.name = "赏金猎人";
        bh.hp = 5000;
        bh.damage = 1;
          
        final Hero leesin = new Hero();
        leesin.name = "盲僧";
        leesin.hp = 4505;
        leesin.damage = 1;
          
        Thread t1= new Thread(){
            public void run(){
 
                while(!teemo.isDead()){
                    gareen.attackHero(teemo);
                }              
            }
        };
          
        Thread t2= new Thread(){
            public void run(){
                while(!leesin.isDead()){
                    bh.attackHero(leesin);
                }              
            }
        };
         
        t1.setPriority(Thread.MAX_PRIORITY);
        t2.setPriority(Thread.MIN_PRIORITY);
        t1.start();
        t2.start();
    }
    /*临时暂停
     * 当前线程，临时暂停，使得其他线程可以有更多的机会占用CPU资源 
     */
    public static void example4() {
        final Hero gareen = new Hero();
        gareen.name = "盖伦";
        gareen.hp = 61600;
        gareen.damage = 1;
  
        final Hero teemo = new Hero();
        teemo.name = "提莫";
        teemo.hp = 30000;
        teemo.damage = 1;
          
        final Hero bh = new Hero();
        bh.name = "赏金猎人";
        bh.hp = 50000;
        bh.damage = 1;
          
        final Hero leesin = new Hero();
        leesin.name = "盲僧";
        leesin.hp = 45050;
        leesin.damage = 1;
          
        Thread t1= new Thread(){
            public void run(){
 
                while(!teemo.isDead()){
                    gareen.attackHero(teemo);
                }              
            }
        };
          
        Thread t2= new Thread(){
            public void run(){
                while(!leesin.isDead()){
                    //临时暂停，使得t1可以占用CPU资源
                    Thread.yield();
                     
                    bh.attackHero(leesin);
                }              
            }
        };
         
        t1.setPriority(5);
        t2.setPriority(5);
        t1.start();
        t2.start();
    }
    /* 守护线程 
     * 守护线程的概念是： 当一个进程里，所有的线程都是守护线程的时候，结束当前进程。
      就好像一个公司有销售部，生产部这些和业务挂钩的部门。
    除此之外，还有后勤，行政等这些支持部门。
    如果一家公司销售部，生产部都解散了，那么只剩下后勤和行政，那么这家公司也可以解散了。
    守护线程就相当于那些支持部门，如果一个进程只剩下守护线程，那么进程就会自动结束。
    守护线程通常会被用来做日志，性能统计等工作。 
     */
    public static void example5() {
        Thread t1= new Thread(){
            public void run(){
                int seconds =0;
                 
                while(true){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.printf("已经玩了LOL %d 秒%n", seconds++);
                     
                }              
            }
        };
        t1.setDaemon(true);
        t1.start();
    }
    /* 练习-英雄充能 
     * 英雄有可以放一个技能叫做: 波动拳-a du gen。
每隔一秒钟，可以发一次，但是只能连续发3次。
发完3次之后，需要充能5秒钟，充满，再继续发。
借助本章节学习到的知识点，实现这个效果 
     */
    public static void example6() {
        Thread t1 = new Thread() {
            public void run() {
 
                    for(int i = 0;i < 5;i ++)
                    {
                        for(int j = 0;j < 3;j ++) {
                            System.out.println("正在发送第"+(j+1)+"波动拳");
                            try {
                                Thread.sleep(1000);
                            }catch(InterruptedException e ) {
                                e.printStackTrace();
                            }
                        }
                        System.out.println("开始为时5s的充能");
                        try {
                            Thread.sleep(5000);
                        }catch(InterruptedException e ) {
                            e.printStackTrace();
                        }
                    }
                }
            
        };
        t1.start();
    }
    /*练习-破解密码
     * 1. 生成一个长度是3的随机字符串，把这个字符串当作 密码
       2. 创建一个破解线程，使用穷举法，匹配这个密码
       3. 创建一个日志线程，打印都用过哪些字符串去匹配，这个日志线程设计为守护线程
提示： 破解线程把穷举法生成的可能密码放在一个容器中，日志线程不断的从这个容器中拿出可能密码，并打印出来。 如果发现容器是空的，就休息1秒，如果发现不是空的，就不停的取出，并打印。

     */
    public static void example7() {
        //提示：破解线程把穷举法生成的可能密码放在一个容器中，日志线程不断的从这个容器中拿出可能密码，并打印出来。 如果发现容器是空的，就休息1秒，如果发现不是空的，就不停的取出，并打印。
        List<String> passwords = new ArrayList<String>();//容器记录产生的可能密码
        //1.生成随机字符串pwd
        String s="0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
        char cs[]=new char[3];
        for(int i=0;i<cs.length;i++) {
            int index=(int)(Math.random()*s.length());
            cs[i]=s.charAt(index);
        }
        String pwd = new String(cs);
        System.out.println("设置的密码为："+pwd);
        //2.创建一个破解线程，使用穷举法，匹配这个密码
        Thread t1 = new Thread() {
            public void run() {
                for(char i='0';i<='z';i++) {
                    if(Character.isDigit(i)||Character.isAlphabetic(i)) {
                        for(char j='0';j<='z';j++) {
                            if(Character.isDigit(j)||Character.isAlphabetic(j)) {
                                for(char k='0';k<='z';k++) {
                                    if(Character.isDigit(k)||Character.isAlphabetic(k)) {
                                        StringBuffer buf=new StringBuffer();
                                        buf.append(i);
                                        buf.append(j);
                                        buf.append(k);
                                        passwords.add(buf.toString());
                                        System.out.println("产生的新密码是："+buf.toString());
                                        if(buf.toString().equals(pwd)) {
                                            System.out.println("找到了，密码是" + buf+"即将退出破解线程");
                                            return;
                                        }else {
                                            System.out.println("...");
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        };
        t1.start();
        //3.创建一个日志线程，打印都用过哪些字符串去匹配，这个日志线程设计为守护线程
        Thread t2= new Thread() {
            public void run() {
                while(true) {
                    if(passwords.isEmpty()) {
                        try {
                            Thread.sleep(1000);
                        }catch(InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println("最新穷举的密码："+passwords.get(passwords.size()-1));
                }
                
            }
        };
        t2.setDaemon(true);
        t2.start();
    }
    public static void main(String[] args) {
        //example1();//当前线程暂停 
        //example2();//在主线程中加入线程
        //example3();//线程优先级 
        //example4();//临时暂停 
        //example5();//守护进程
        
        
        //example6();//作业1-波动拳
        example7();//作业2-破解密码
        
    }
}