码迷，mamicode.com
首页 > 编程语言 > 详细

java--线程--习题集锦

时间：2018-05-06 00:24:15      阅读：952      评论：0      收藏：0      [点我收藏+]

标签：oat   hand   let   匿名类   case   current   unlock   mys   tst   

匿名类的一个好处是可以很方便的访问外部的局部变量。
前提是外部的局部变量需要被声明为final。(JDK7以后就不需要了)
技术分享图片

======================

同步方法1：普通式

技术分享图片

同步方法2：在对象方法里 写关键字,用this

技术分享图片

同步方法3：在方法前，加上修饰符synchronized，效果等同方法2

技术分享图片

==================

题目1--同步查找文件内容

把 练习-查找文件内容 改为多线程查找文件内容
原练习的思路是遍历所有文件，当遍历到文件是 .java的时候，查找这个文件的内容，查找完毕之后，再遍历下一个文件

现在通过多线程调整这个思路：
遍历所有文件，当遍历到文件是.java的时候，创建一个线程去查找这个文件的内容，不必等待这个线程结束，继续遍历下一个文件

package zsc.czy.zhonghe;

import java.io.File;
import java.io.FileReader;

public class findContent {

    public static void main(String[] args) {
        File f = new File("d:/test");
        
        search(f, "Hello");
    }

    public static void search(File f, String search) {
        System.out.println(f); //d:\find.txt
        System.out.println(f.getAbsolutePath());
//      System.out.println(f.getName());//find.txt
        if (f.isFile()) {
            if (f.getName().toLowerCase().endsWith(".java")) {
                new Thread(new Runnable() {
                    
                    @Override
                    public void run() {
                        String fileContent = readFileConent(f);
                        if (fileContent.contains(search)) {
                            System.out.printf("找到子目标字符串%s,在文件:%s%n", search, f);
                        }
                    }
                }).start();
                
            }
        }
        if(f.isDirectory()){
            File[] fs = f.listFiles();
            for(File file :fs){
                search(file,search);
            }
        }

    }

    private static String readFileConent(File f) {
        try (FileReader fr = new FileReader(f);) {
            char[] c = new char[(int) f.length()];
            fr.read(c);
            String s = new String(c);
            return s;

        } catch (Exception e) {
            return null;
        }

    }
}

题目2--英雄充能

英雄有可以放一个技能叫做: 波动拳-a du gen。
每隔一秒钟，可以发一次，但是只能连续发3次。

发完3次之后，需要充能5秒钟，充满，再继续发。
技术分享图片

package zsc.czy.thread;

public class Hero {
    String name;
    int hp;
    int damage;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getHp() {
        return hp;
    }

    public void setHp(int hp) {
        this.hp = hp;
    }

    public int getDamage() {
        return damage;
    }

    public void setDamage(int damage) {
        this.damage = damage;
    }

    public boolean isDead() {
        return 0 >= hp ? true : false;
    }

    public void attackHero(Hero h) {
        try {
            // 为了表示攻击需要时间，每次攻击暂停1000毫秒
            Thread.sleep(1000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        h.hp -= damage;
        System.out.format("%s 正在攻击 %s,%s的血编程了 %.0f%n", name, h.name, h.name,
                h.hp);
        if (h.isDead()) {
            System.out.println(h.name + "死了");
        }
    }

    int totalTime = 3;

    public void adugen() {
        while (true) {
            for (int i = 0; i < totalTime; i++) {
                System.out.printf("波动拳第%d发%n", i + 1);
                try {
                    Thread.sleep(1000);
                } catch (Exception e) {
                    // TODO: handle exception
                }
            }
            System.out.println("开始为时5秒的充能");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {

                e.printStackTrace();
            }

        }
    }

    public static void main(String[] args) {
        Hero h = new Hero();
        h.name = "红仔";
        h.adugen();
    }
}

题目3--破解密码

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

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

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

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

==============================

HashMap不严格 可以存放 null --不是线程安全的类
Hashtable严格

ArrayList是非线程安全的
Vector是线程安全的类

====================

题目4-线程安全的MyStack

借助把非线程安全的集合转换为线程安全，用另一个方式完成 练习-线程安全的MyStack
技术分享图片

题目5--死锁

3个同步对象a, b, c
3个线程 t1,t2,t3

故意设计场景，使这3个线程彼此死锁

//我这样设计是不成功的
package zsc.czy.thread;

public class SiSuo {
    public static void main(String[] args) {
        final Hero ahri = new Hero();
        ahri.name = "九尾妖狐";
        final Hero annie = new Hero();
        annie.name = "安妮";
        final Hero leqing = new Hero();
        annie.name = "李青";

        Thread t1 = new Thread() {
            public void run() {
                // 占有九尾妖狐
                synchronized (ahri) {
                    System.out.println("t1 已占有九尾妖狐");
                    try {
                        // 停顿1000毫秒，另一个线程有足够的时间占有安妮
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }

                    System.out.println("t1 试图占有安妮");
                    System.out.println("t1 等待中 。。。。");
                    synchronized (annie) {
                        System.out.println("do something");
                    }
                }

            }
        };
        t1.start();
        Thread t2 = new Thread() {
            public void run() {
                // 占有安妮
                synchronized (annie) {
                    System.out.println("t2 已占有安妮");
                    try {

                        // 停顿1000秒，另一个线程有足够的时间占有暂用九尾妖狐
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println("t2 试图占有李青");
                    System.out.println("t2 等待中 。。。。");
                    synchronized (leqing) {
                        System.out.println("do something");
                    }
                }

            }
        };
        t2.start();
        
        Thread t3 = new Thread(){
            public void run() {
                synchronized (leqing) {
                    System.out.println("t3已占有李青");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        
                        e.printStackTrace();
                    }
                    System.out.println("t3 试图占有九尾妖狐");
                    System.out.println("t3 等待中 。。。。");
                }
                synchronized (ahri) {
                    System.out.println("do something");
                }
                
            };
        };
        t3.start();
    }
}

正确做法为：

package multiplethread;
 
public class TestThread {
       
    public static void main(String[] args) {
        Object a = new Object();
        Object b = new Object();
        Object c = new Object();
 
        Thread t1 =new Thread(){
            public void run(){
                synchronized (a) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    synchronized (b) {
                        synchronized (c) {
                             
                        }
                    }
                }  
            }
        };
        Thread t2 =new Thread(){
            public void run(){
                synchronized (c) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    synchronized (a) {
                        synchronized (b) {
                             
                        }
                    }
                }  
            }
        };
        Thread t3 =new Thread(){
            public void run(){
                synchronized (b) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    synchronized (c) {
                        synchronized (a) {
                             
                        }
                    }
                }  
            }
        };
 
        t1.start();
        t2.start();
        t3.start();
        
   }
         
}

================

使用wait和notify进行线程交互

this.wait()表示 让占有this的线程等待，并临时释放占有
this.notify() 表示通知那些等待在this的线程，可以苏醒过来了。

public synchronized void recover() {
        hp = hp + 1;
         System.out.printf("%s 回血1点,增加血后，%s的血量是%.0f%n", name, name, hp);
        // 通知那些等待在this对象上的线程，可以醒过来了，如第20行，等待着的减血线程，苏醒过来
        this.notify();
    }

    // 掉血  同步方式和上面效果一样 这个方式
    public void hurt() {
        synchronized (this) {
            if (hp == 1) {
                // 让占有this的减血线程，暂时释放对this的占有，并等待
                try {
                    this.wait();
                } catch (InterruptedException e) {

                    e.printStackTrace();
                }
            }
            hp = hp - 1;
            System.out.printf("%s 减血1点,减少血后，%s的血量是%.0f%n", name, name, hp);

        }
    }

技术分享图片

别忘了Thread 父类也是Object

题目--线程交互

假设加血线程运行得更加频繁，英雄的最大血量是1000

设计加血线程和减血线程的交互，让回血回满之后，加血线程等待，直到有减血线程减血

    // 回血
    public synchronized void recover() {
        
        if(hp>=1000){
            try {
                this.wait(); //后加的
            } catch (InterruptedException e) {
                
                e.printStackTrace();
            }
        }
        
        hp = hp + 1;
        System.out.printf("%s 回血1点,增加血后，%s的血量是%.0f%n", name, name, hp);
        // 通知那些等待在this对象上的线程，可以醒过来了，如第73行，等待着的减血线程，苏醒过来
        this.notify(); 
    }

    // 掉血  同步方式和上面效果一样 这个方式
    public void hurt() {
        synchronized (this) {
            if (hp == 1) {
                // 让占有this的减血线程，暂时释放对this的占有，并等待
                try {
                    this.wait();
                } catch (InterruptedException e) {

                    e.printStackTrace();
                }
            }
            hp = hp - 1;
            System.out.printf("%s 减血1点,减少血后，%s的血量是%.0f%n", name, name, hp);
            
            //notify() 的意思是，通知一个等待在这个同步对象上的线程，你可以苏醒过来了，有机会重新占用当前对象了。
            //掉血之后，唤醒等待的线程
            this.notify();//后加的
        }
    }

题目--多线程交互

在上面的练习的基础上，增加回血线程到2条，减血线程到5条，同时运行。

运行一段时间，观察会发生的错误，分析错误原因，并考虑解决办法

技术分享图片

技术分享图片

题目--生产者消费者问题

生产者消费者问题是一个非常典型性的线程交互的问题。

  1. 使用栈来存放数据
    1.1 把栈改造为支持线程安全
    1.2 把栈的边界操作进行处理，当栈里的数据是0的时候，访问pull的线程就会等待。 当栈里的数据时200的时候，访问push的线程就会等待
  2. 提供一个生产者（Producer）线程类，生产随机大写字符压入到堆栈
  3. 提供一个消费者（Consumer）线程类，从堆栈中弹出字符并打印到控制台
  4. 提供一个测试类，使两个生产者和三个消费者线程同时运行，结果类似如下 ：

技术分享图片

技术分享图片

技术分享图片

技术分享图片

技术分享图片

==================

Lock

技术分享图片

题目

在练习-线程安全的MyStack 练习中，使用synchronized把MyStack修改为了线程安全的类。

接下来，借助Lock把MyStack修改为线程安全的类

把synchronized去掉
使用lock占用锁
使用unlock释放锁
必须放在finally执行，万一heros.addLast抛出异常也会执行

package multiplethread;
    
import java.util.LinkedList;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
import charactor.Hero;
    
public class MyStack {
    
    LinkedList<Hero> heros = new LinkedList<Hero>();
 
    Lock lock = new ReentrantLock();
     
    //把synchronized去掉
    public  void push(Hero h) {
        try{
            //使用lock占用锁
            lock.lock();
            heros.addLast(h);          
        }
        finally{
            //使用unlock释放锁
            //必须放在finally执行，万一heros.addLast抛出异常也会执行
            lock.unlock();
        }
     
    }
    
    //把synchronized去掉
    public  Hero pull() {
        try{
            //使用lock占用锁
            lock.lock();
            return heros.removeLast();         
        }
        finally{
            //使用unlock释放锁
            //必须放在finally执行，万一heros.removeLast();抛出异常也会执行          
            lock.unlock();
        }
    }
    
    public Hero peek() {
        return heros.getLast();
    }
        
    public static void main(String[] args) {
 
    }
    
}

题目--借助tryLock 解决死锁问题

当多个线程按照不同顺序占用多个同步对象的时候，就有可能产生死锁现象。

死锁之所以会发生，就是因为synchronized 如果占用不到同步对象，就会苦苦的一直等待下去，借助tryLock的有限等待时间，解决死锁问题

package multiplethread;
  
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
  
public class TestThread {
  
    public static void main(String[] args) throws InterruptedException {
        Lock lock_ahri = new ReentrantLock();
        Lock lock_annie = new ReentrantLock();
  
        Thread t1 = new Thread() {
            public void run() {
                // 占有九尾妖狐
                boolean ahriLocked = false;
                boolean annieLocked = false;
                  
                try {
                    ahriLocked = lock_ahri.tryLock(10, TimeUnit.SECONDS);
                    if (ahriLocked) {
                        System.out.println("t1 已占有九尾妖狐");
                        // 停顿1000秒，另一个线程有足够的时间占有安妮
                        Thread.sleep(1000);
                        System.out.println("t1 试图在10秒内占有安妮");
                        try {
                            annieLocked = lock_annie.tryLock(10, TimeUnit.SECONDS);
                            if (annieLocked)
                                System.out.println("t1 成功占有安妮，开始啪啪啪");
                            else{
                                System.out.println("t1 老是占用不了安妮，放弃");
                            }
  
                        } finally {
                            if (annieLocked){
                                System.out.println("t1 释放安妮");
                                lock_annie.unlock();
                            }
                        }
  
                    }
                } catch (InterruptedException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                } finally {
                    if (ahriLocked){
                        System.out.println("t1 释放九尾狐");
                        lock_ahri.unlock();
                    }
                }
  
            }
        };
        t1.start();
          
        Thread.sleep(100);
          
        Thread t2 = new Thread() {
            public void run() {
                boolean annieLocked = false;
                boolean ahriLocked = false;
                                  
                try {annieLocked = lock_annie.tryLock(10, TimeUnit.SECONDS);
                  
                if (annieLocked){
                      
                        System.out.println("t2 已占有安妮");
                        // 停顿1000秒，另一个线程有足够的时间占有安妮
                        Thread.sleep(1000);
                        System.out.println("t2 试图在10秒内占有九尾妖狐");
                        try {
                            ahriLocked = lock_ahri.tryLock(10, TimeUnit.SECONDS);
                            if (ahriLocked)
                                System.out.println("t2 成功占有九尾妖狐，开始啪啪啪");
                            else{
                                System.out.println("t2 老是占用不了九尾妖狐，放弃");
                            }
                        }
                        finally {
                            if (ahriLocked){
                                System.out.println("t2 释放九尾狐");
                                lock_ahri.unlock();
                            }
                                  
                        }
  
                    }
                } catch (InterruptedException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                } finally {
                    if (annieLocked){
                        System.out.println("t2 释放安妮");
                        lock_annie.unlock();
                    }
                          
                }
            }
        };
        t2.start();
      
    }
}

题目--生产者消费者问题

在练习-生产者消费者问题这个练习中，是用wait(), notify(), notifyAll实现了。

接下来使用Condition对象的：await, signal,signalAll 方法实现同样的效果

package multiplethread;
 
import java.util.LinkedList;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
public class MyStack<T> {
 
    LinkedList<T> values = new LinkedList<T>();
 
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
 
    public void push(T t) {
        try {
            lock.lock();
            while (values.size() >= 200) {
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            condition.signalAll();
            values.addLast(t);
        } finally {
            lock.unlock();
        }
 
    }
 
    public T pull() {
        T t=null;
        try {
            lock.lock();
            while (values.isEmpty()) {
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            condition.signalAll();
            t= values.removeLast();
        } finally {
            lock.unlock();
        }
        return t;
    }
 
    public T peek() {
        return values.getLast();
    }
}

题目--使用AtomicInteger来替换Hero类中的synchronized

在给Hero的方法加上修饰符synchronized 这个知识点中，通过给hurt和 recover方法加上synchronized来达到线程安全的效果。

这一次换成使用AtomicInteger来解决这个问题

提示：int基本类型对应的是AtomicInteger，但是float基本类型没有对应的AtomicFloat。 所以在这个练习中，把hp改为AtomicInteger即可。
技术分享图片

java--线程--习题集锦

标签：oat   hand   let   匿名类   case   current   unlock   mys   tst   

原文地址：https://www.cnblogs.com/czy16/p/8996587.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！