Java学习-多线程的创建

多线程查找文件内容

遍历所有文件，当遍历到文件名是.java结尾的时候，创建一个线程去查找这个文件的内容（是否包含“Magic”字符串），不必等待这个线程结束，继续遍历下一个文件。

package multiplethread;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class searchFileInDirectory {
    // 实现Runnable接口方式的多线程
    public static void funcThread1(String path) {
        File f = new File(path);
        if (f.exists()) {
            File[] fs = f.listFiles();
            for (File x : fs) {
                if (x.isDirectory())
                    funcThread1(x.getAbsolutePath());
                if (x.isFile() && x.getName().contains(".java")) {
                    new Thread(new searchInFile(x)).start();
                }
            }
        }
    }

    public static void checkFile(File x) {
        Thread t = new Thread() {
            public void run() {
                try (BufferedReader br = new BufferedReader(new FileReader(x));) {
                    while (true) {
                        String line = br.readLine();
                        if (line == null)
                            break;
                        if (line.contains("Magic")) {
                            System.out.printf("找到目标字符串"Magic",在文件%s%n", x.getAbsoluteFile());
　　　　　　　　　　　　　　　　　　　　break;// 只要文件含有content，不管出现多少次，只打印一次文件地址
                        }
                    }
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }

        };
        t.start();
    }

    // 匿名类的方式的多线程
    public static void funcThread2(String path) {
        File f = new File(path);
        if (f.exists()) {
            File[] fs = f.listFiles();
            for (int i = 0; i < fs.length; i++) {
                File x = fs[i];
                if (x.isDirectory()) {
                    funcThread2(x.getAbsolutePath());
                }
                if (x.isFile() && x.getName().contains(".java")) {
                    checkFile(x); // 理论上直接写到这里可以，但是为了美观便于阅读，就单独写到checkFile()中
                }
            }

        }
    }

    // 单线程
    public static void funcNoThread(String path) {
        File f = new File(path);
        if (f.exists()) {
            File[] fs = f.listFiles();
            for (File x : fs) {
                if (x.isDirectory())
                    funcNoThread(x.getAbsolutePath());
                if (x.isFile() && x.getName().contains(".java")) {
                    try (BufferedReader br = new BufferedReader(new FileReader(x));) {
                        while (true) {
                            String line = br.readLine();
                            if (line == null)
                                break;
                            if (line.contains("Magic")) {
                                System.out.printf("找到目标字符串"Magic",在文件%s%n", x.getAbsoluteFile());
                            }
                        }
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }

                }
            }
        }
    }

    public static void main(String[] args) {
        String path = "F:\project\javastudy";
        long st1 = System.currentTimeMillis();
        funcThread1(path);
        long et1 = System.currentTimeMillis();
        System.out.printf("多线程Thread1下花费时间：%d ms", et1 - st1);

        long st2 = System.currentTimeMillis();
        funcThread2(path);
        long et2 = System.currentTimeMillis();
        System.out.printf("多线程Thread2下花费时间：%d ms", et2 - st2);

        long st3 = System.currentTimeMillis();
        funcNoThread(path);
        long et3 = System.currentTimeMillis();
        System.out.printf("单线程下花费时间：%d ms", et3 - st3);
    }
}

效果图：

 ...

 ...

 由于文件数量较少，多线程与单线程所耗时间基本一致。

 练习-英雄充能

英雄有可以放一个技能叫做: 波动拳-a du gen。
每隔一秒钟，可以发一次，但是只能连续发3次。
发完3次之后，需要充能5秒钟，充满，再继续发。

package multiplethread;

import charactor.Hero;

public class ThreadTest2 {

    public static void main(String[] args) {
        Thread t1 = new Thread() {
            private int cnt = 0;

            public void run() {
                while (true) {
                    if ((++cnt) % 4 != 0) {
                        System.out.printf("波动拳第%d发
", cnt);
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    } else {
                        cnt = 0;
                        try {
                            System.out.println("开始为时5秒的充能");
                            Thread.sleep(5000);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                }
            }
        };
        t1.start();

    }
}

效果图：

练习-破解密码

1. 生成一个长度是3的随机字符串，把这个字符串当作密码

2. 创建一个破解线程，使用穷举法，匹配这个密码

3. 创建一个日志线程，打印都用过哪些字符串去匹配，这个日志线程设计为守护线程：setDaemon(true)

提示： 破解线程把穷举法生成的可能密码放在一个容器中，日志线程不断的从这个容器中拿出可能密码，并打印出来。 如果发现容器是空的，就休息1秒，如果发现不是空的，就不停的取出，并打印。

package multiplethread;

import java.util.LinkedList;
import java.util.Random;

public class Test2 {
    public static String getRandomString(int length) {
        String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        Random random = new Random();
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < length; i++) {
            int number = random.nextInt(62);
            sb.append(str.charAt(number));
        }
        return sb.toString();
    }

    public static void main(String[] args) throws InterruptedException {
        String pwd = getRandomString(3);
        LinkedList<String> pwdList = new LinkedList<>();
        System.out.println("pwd :" + pwd);
        Thread t1 = new Thread() {
            String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
            int n = str.length();
            char[] cs = new char[3];

            public void run() {
                ok: for (int i = 0; i < n; i++) {
                    for (int j = 0; j < n; j++) {
                        for (int k = 0; k < n; k++) {
                            cs[0] = str.charAt(i);
                            cs[1] = str.charAt(j);
                            cs[2] = str.charAt(k);
                            String guess = new String(cs);
                            pwdList.add(guess);
                            // t1和t2这两个线程并发执行，但是t2由于要挨个打印，必然晚于t1结束，而t1早已经匹配到密码
                            // 不妨令t1匹配到密码时等一等t2，等t2打印完。
                            // 这里设置为等5秒钟（5秒钟基本能匹配成功）
                            if (guess.equals(pwd)) {
                                try {
                                    Thread.sleep(3000);
                                } catch (InterruptedException e) {
                                    // TODO Auto-generated catch block
                                    e.printStackTrace();
                                }
                                System.out.println("匹配成功！密码是：" + guess);
                                break ok;
                            }
                        }
                    }
                }
            }
        };
        Thread t2 = new Thread() {
            public void run() {
                while (true) {
                    String tmp = pwdList.poll();
                    // 发现容器是空的，就休息1秒
                    if (tmp == null) {
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    } else {
                        System.out.println("可能是：" + tmp);
                    }
                }
            }
        };
        t2.setDaemon(true);
        t1.start();
        t2.start();
    }
}

效果图：

 练习-多线程交互

 对同一个对象（Hero），有2个加血线程，5个扣血线程，同时运行。最大血量1000，最小血量1。

使用wait()、notify()。

其中Hero类的加血、扣血方法如下：

    //回血
        public synchronized void recover(){
            if(hp==1000){
                try {
                    this.wait();    //满血不能再加血
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }else{
                hp=hp+1;
                System.out.printf("%s 回血1点,增加血后，%s的血量是%.0f%n", name, name, hp);
                this.notify();        //不满血则可以扣血（自然可以加血）
            }
        }
         
        //扣血
        public synchronized void hurt(){
            if(hp<=1){
                try {
                    this.wait();    //空血不能再扣血
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }else{
                hp-=1;
                System.out.printf("%s 减血1点,减少血后，%s的血量是%.0f%n", name, name, hp);
                this.notify();        //非空血可以加血（自然可以扣血）
            }  
        }

多线程交互：

package multiplethread;

import charactor.Hero;

public class Test_wait_notify {
    
    public static void main(String[] args) {
        final Hero gareen = new Hero();
        gareen.name = "盖伦";
        gareen.hp = 616;
        
        Thread addHP[]=new Thread[2];
        Thread reduceHP[]=new Thread[5];
      //2条加血线程
        for(int i=0;i<2;i++){
            Thread t=new Thread(){
                public void run(){
                    while(true){
                        gareen.recover();
                        //加血间隔 10ms
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                }
            };
            t.start();
            addHP[i]=t;
        }
        //5条扣血线程
        for(int i=0;i<5;i++){
            Thread t=new Thread(){
                public void run(){
                    while(true){
                        gareen.hurt();
                        //扣血间隔 10ms
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                }
            };
            t.start();
            reduceHP[i]=t;
        }
        
    }
}

效果图：