多线程习题

最新推荐文章于 2024-07-17 06:03:52 发布
最新推荐文章于 2024-07-17 06:03:52 发布
阅读量138 收藏
点赞数
分类专栏： 并发 文章标签： rabbitmq java rust
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Linging_24/article/details/115868846
版权
  1. 三个线程t1、t2、t3。确保三个线程，t1执行完后t2执行，t2执行完后t3执行。
使用Semaphore
  1. 三个线程t1、t2、t3。确保三个线程，t1，t2执行完，t3再执行。
public class Test01 {

    private Object obj = new Object();
	
    //线程1、2执行完后，再执行线程3，使用wait()、notify()
    public static void main(String[] args) {
        new Test01().exec();
    }

    public void exec(){
        new Thread(()->{
            synchronized (obj){
                try {
                    obj.wait();
                    System.out.println("线程："+Thread.currentThread().getName()+"=>执行了....");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },String.valueOf(3)).start();

        for (int i = 0; i < 2; i++) {
            final int tmp = i;
            new Thread(()->{
                synchronized (obj){
                    System.out.println("线程：" + Thread.currentThread().getName() + "=>执行了....");
                    if(tmp == 1)
                        obj.notify();
                }
            },String.valueOf(i+1)).start();
        }
    }
}

public class Test02 {

    private CountDownLatch latch =new CountDownLatch(2);

    //线程1、2执行完后，再执行线程3，使用CountDownLatch
    public static void main(String[] args) {
        new Test02().exec();
    }

    public void exec(){
        new Thread(()->{
            try {
                latch.await();
                System.out.println(Thread.currentThread().getName() + "=>执行了....");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"线程3").start();

        for (int i = 0; i < 2; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName() + "=>执行了....");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                latch.countDown();
            },String.valueOf("线程" + (i+1))).start();
        }
    }
}

class T1 implements Runnable{

	@Override
	public void run() {
		System.out.println("1");
	}	
}

class T2 implements Runnable{

	Thread father;
	
	public void set(Thread father) {
		this.father = father;
	}
	
	@Override
	public void run() {
		try {
			father.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("2");
	}
}

class T3 implements Runnable{

	Thread father;
	
	public void set(Thread father) {
		this.father = father;
	}
	
	@Override
	public void run() {
		try {
			father.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("3");
	}
}

public class Test {
	//使用join
	public static void main(String[] args) {
		T1 task1 = new T1();
		T2 task2 = new T2();
		T3 task3 = new T3();
		
		Thread t1 = new Thread(task1);
		Thread t2 = new Thread(task2);
		Thread t3 = new Thread(task3);
		
		task2.set(t1);
		task3.set(t1);
		
		t1.start();
		t2.start();
		t3.start();
	}
}
  1. 现有的程序代码模拟产生了16个日志对象，并且需要运行16秒才能打印完这些日志，请在程序中增加4个线程去调用parseLog()方法来分头打印这16个日志对象，程序只需要运行4秒即可打印完这些日志对象。
public class Test {

    /**
     * 现有的程序代码模拟产生了16个日志对象，并且需要运行16秒才能打印完这些日志，
     * 请在程序中增加4个线程去调用parseLog()方法来分头打印这16个日志对象，程序只需要运行4秒即可打印完这些日志对象;
     * 思路1：
     *      1.将16个日志对象放到阻塞队列中
     *      2.开启4个线程从阻塞队列中拿日志对象执行
     *      3.日志对象执行时间为 1s
     *      4.此方式线程会一直跑，阻塞
     *
     * 思路2：
     *      1.创建具有4个核心线程的线程池
     *      2.在阻塞队列中加入16个打印日志对象的任务
     *      3.执行线程池的任务
     *      4.日志对象执行时间为 1s
     *      5.此方式线程会销毁
     *
     */
    public static void main(String[] args) {
        test01();   //思路1实现
        //test02();   //思路2实现
    }

    private static void test01() {
        long start = System.currentTimeMillis();
        BlockingQueue<String> queue = new ArrayBlockingQueue<String>(16);

        //将16个日志对象放入阻塞队列中
        for (int i = 1; i <= 16; i++) {
            try {
                queue.put("日志对象：" + i);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //开启4个线程从阻塞队列中拿日志对象执行
        for (int i = 0; i < 4; i++) {
            new Thread(()->{
                while(true){
                    try {
                        String log = queue.take();
                        printLog(log);
                        long end = System.currentTimeMillis();
                        System.out.println((end-start) + "ms");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }


    public static void test02(){
        long start = System.currentTimeMillis();
        BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(16);

        //创建具有四个核心线程的线程池
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
                4,
                4,
                3000,
                TimeUnit.MILLISECONDS,
                queue,
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.CallerRunsPolicy()
        );

        //将16个打印日志对象的任务放入阻塞队列中
        for (int i = 0; i < 16; i++) {
            final String tmp = "任务" + (i+1) + "";
            poolExecutor.execute(()->{
                printLog(tmp);
            });
        }
        poolExecutor.shutdown();

        //判断线程池的任务是否执行完毕
        while(true){
            long end = System.currentTimeMillis();
            if(poolExecutor.isTerminated()){
                System.out.println((end-start) + "ms");
                break;
            }
        }
    }

    public static void printLog(String log){
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "===>打印日志=========>" + log);
    }

}
  1. 10个线程同步执行10个任务
public class Test2 {

    /**
     * 10个线程同步执行10个任务
     * 方式1：synchronized
     * 方式2：Lock
     * 方式3：Semaphore
     * @param args
     */
    public static void main(String[] args) {
        //test01();   //synchronized
        //test02();   //Lock
        test03();     //Semaphore
    }


    public static void test01(){
        BlockingQueue<String> queue = new ArrayBlockingQueue<String>(10);
        //往阻塞队列中加入任务
        for (int i = 0; i < 10; i++) {
            try {
                queue.put("任务：" + (i+1));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //10个线程顺序执行任务
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                synchronized (queue){
                    try {
                        String task = queue.take();
                        executeTask(task);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }

    public static void test02(){
        BlockingQueue<String> queue = new ArrayBlockingQueue<>(10);
        Lock lock = new ReentrantLock();
        //往阻塞队列中加入任务
        for (int i = 0; i < 10; i++) {
            try {
                queue.put("任务：" + (i+1));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //10个线程顺序执行任务
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                try {
                    lock.lock();
                    String task = queue.take();
                    executeTask(task);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    lock.unlock();
                }
            }).start();
        }
    }

    public static void test03(){
        BlockingQueue<String> queue = new ArrayBlockingQueue<String>(10);
        Semaphore semaphore = new Semaphore(1);
        //往阻塞队列中加入任务
        for (int i = 0; i < 10; i++) {
            try {
                queue.put("任务：" + (i+1));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //10个线程顺序执行任务
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                try {
                    semaphore.acquire();
                    String task = queue.take();
                    executeTask(task);
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }

    }

    public static void executeTask(String task){
        System.out.println(Thread.currentThread().getName() + "==>" + task);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
  1. 10个商品被20个用户抢购，如何让商品正常卖出，不会超卖：
public class Test03 {

    //10个商品
    private int goods = 10;
    
    public static void main(String[] args) {
        new Test03().exec();
    }

    public synchronized void exec(){
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                if(goods > 0){
                    System.out.println(Thread.currentThread().getName() + "，抢到了第 " + goods-- + " 张票");
                }
            },String.valueOf("用户" + (i+1))).start();
        }
    }
}
  1. 生产者消费者问题
//数据
class Data{
	
	private String message;
	
	public String getMessage() {
		return message;
	}
	
	public void setMessage(String message) {
		this.message = message;
	}
}


//生产者
class Producer implements Runnable{

	private Data data;
	
	public Producer(Data data) {
		this.data = data;
	}
	
	@Override
	public void run() {
		int i = 0;
		while(true) {
			synchronized(data){
				//如果数据为空，则生产数据
				if(data.getMessage() == null) {
					data.setMessage(i + "");
					System.out.println("生产：" + i);
					i++;
				}
				//生产完数据通知消费者消费
				data.notify();
				//生产者挂起
				try {
					data.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

//消费者
class Consumer implements Runnable{
	private Data data;
	
	public Consumer(Data data) {
		this.data = data;
	}
	
	public void run() {
		while(true) {
			synchronized(data) {
				//如果数据不为空，则消费
				if(data.getMessage() != null) {
					System.out.println("消费：" + data.getMessage());
					data.setMessage(null);
				}
				//消费完，通知生产者进行生产
				data.notify();
				//消费者挂起
				try {
					data.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}

}


public class Test {
	
	public static void main(String[] args) {
		Data data = new Data();
		Producer p = new Producer(data);
		Consumer c = new Consumer(data);
		
		Thread t1 = new Thread(p);
		Thread t2 = new Thread(c);
		
		t1.start();
		t2.start();
	}
}
  1. 优雅的停止线程
class Task implements Runnable{
	
	private volatile boolean isFlag = true;
	
	public void stop() {
		this.isFlag = false;
	}
	
	public void run() {
		int i = 0;
		while(isFlag) {
			System.out.println(i++);
		}
	}
}

public class Test {
	//使用标志位
	public static void main(String[] args) throws InterruptedException {
		Task task = new Task();
		Thread t = new Thread(task);
		t.start();
		TimeUnit.SECONDS.sleep(1);
		task.stop();
	}
}

class Task implements Runnable{
	
	public void run() {
		int i = 0;
		while(true) {
			Thread t = Thread.currentThread();
			if(t.isInterrupted()) {  //判断是否处于中断状态
				break;
			}
			System.out.println(i++);
		}
	}
}

public class Test {
	//使用interrupt
	public static void main(String[] args) throws InterruptedException {
		Task task = new Task();
		Thread t = new Thread(task);
		t.start();
		TimeUnit.SECONDS.sleep(1);
		t.interrupt();  //中断
	}
}
  1. 多线程循环顺序打印：ABABABABAB，线程A打印A，线程B打印B。
使用Object.wait()和notifyAll()  或者Lock + Condition
  1. 多线程循环顺序打印：0102030405，线程0打印0，线程1打印奇数，线程2打印偶数
使用Object.wait()和notifyAll()  或者Lock + Condition

代码后续更新。。。

shutdown和shutwdown的区别：

  • shutdown只是将线程池的状态设置为SHUTWDOWN状态，正在执行的任务会继续执行下去，没有被执行的则中断。
  • shutdownNow则是将线程池的状态设置为STOP，正在执行的任务则被停止，没被执行任务的则返回。

isShutDown：

  • isShutDown当调用shutdown()或shutdownNow()方法后返回为true。
  • isTerminated当调用shutdown()方法后，并且所有提交的任务完成后返回为true;
  • isTerminated当调用shutdownNow()方法后，成功停止后返回为true;
Linging_24
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java高级特性 - 多线程练习题
Junds0的博客
06-29 567
本关任务：利用多线程相关知识控制三个线程，依照先后顺序顺序输出。 第2关：售票窗口 本关任务：利用多线程技术，编写一个卖票的小程序，
Java多线程练习题
Alphamilk的博客
07-25 344
巩固多线程的学习
java多线程练习题
xwt1130_的博客
11-13 1068
java多线程练习题
多线程练习题
博客
05-14 2313
多线程练习题 1.写一段简单的程序，启动两个线程交替打印1–100 题目分析： 只打印1—100，为了保证数据的同步必须加锁，同时又需要线程交替打印，则需要线程间的通信。 解题思想： 启动两个线程A和线程B，两个线程交替打印，首先A打印，打印完，wait，释放对象锁，此时B获得对象锁，打印，且唤醒A，然后B wait ,反复执行。 代码： /** * 两个线程交替输出1--100 * @aut...
头歌Educoder——Java高级特性 - 多线程练习题
热门推荐
赵士杰——成功并非一蹴而就，而是在持之以恒的努力中逐渐实现。
03-24 1万+
文章目录第1关：顺序输出任务描述相关知识（略）编程要求测试说明代码示例第2关：售票窗口任务描述相关知识（略）编程要求测试说明代码示例Station.javaTask.java 第1关：顺序输出 任务描述 本关任务：利用多线程相关知识控制三个线程，依照先后顺序顺序输出。 相关知识（略） 编程要求 请仔细阅读右侧代码，在 Begin-End 区域内进行代码补充，使线程依照先后顺序依次输出JavaThread+线程名。 提示：我们知道线程的执行结果是随机的，什么时候执行线程是看哪一个线程抢占到了CPU的资源，现在
python 选择题 多线程_python多线程练习题
weixin_39792747的博客
12-11 341
python多线程练习题多线程练习题目，涉及知识点较多，属于很好的练习题。题目要求通过多线程实现类似linux中的>>功能，也就是将日志记录到指定的文件中。题目分析基本为main.py写主要处理逻辑，utils.py构造工具类及对应的方法。main.py定义Server()类，类中定义方法输出内容。实例化工具类，启动线程，设置标准输出和错误输出至日志文件。实例化Server()类并调用...
JavaSE多线程练习题
天问的博客
04-12 927
JavaSE多线程练习题简答题1判断填空简答题2编程参考文献 简答题1 1.java中有几种方法可以实现一个线程(jdk5.0之前)？用什么关键字修饰同步方法? stop()和suspend()方法为何不推荐使用？ 有两种实现方法，分别是继承Thread类与实现Runnable接口。 用synchronized关键字修饰同步方法， 反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。 su
C++ 多线程练习题 以及知识点
qq_38409301的博客
12-22 2521
转载：一些c++多线程习题 - geloutingyu - 博客园 (cnblogs.com) 知识点： this_thread::yield(); //当前线程放弃执行，操作系统调度另一线程继续执行 自己手写练习才有感觉： 第一题：子线程循环10次，接着主线程循环100次，接着又回到子线程循环10次，接着再回到主线程又循环100次，如此循环50次，试写出代码 方法一：采用this_thread::yield(); #include <thread> #includ...
Java 多线程 习题
亮点菌
08-20 548
1、设计4个线程对象，两个线程执行减操作，两个线程执行加操作。 2、设计一个生产电脑和搬运电脑类，要求生产出一台电脑就搬走一台电脑，如果没有新的电脑生产出来，则搬运工要等待新电脑产出；如果生产出的电脑没有搬走，则要等待电脑搬走之后再生产，并统计出生产的电脑数量。
多线程练习题java
11-09
java多线程初学者练习题目，供初学者练习使用
JAVA多线程练习题答案。
04-13
JAVA多线程练习题答案详解 在本文中，我们将对 JAVA 多线程练习题的答案进行详细的解释和分析。这些题目涵盖了 JAVA 多线程编程的基本概念和技术，包括线程的生命周期、线程同步、线程状态、线程优先级、线程安全等...
Java高级特性 - 多线程练习题.zip
06-07
在这个"Java高级特性 - 多线程练习题.zip"中，我们可以看到两个文件，分别是"顺序输出.txt"和"售票窗口.txt"，它们很可能是用来展示或测试多线程编程概念的例子。 1. **线程的创建与启动** Java中创建线程主要有两...
多线程练习题卷.pdf
10-24
多线程练习题卷.pdf
消息队列-RabbitMQ
Roc的博客
07-16 420
延迟队列是一种消息队列，它允许消息在被发送后延迟一定时间才被消费者处理。这意味着消息可以设定一个未来的时间点进行投递，直到达到指定的延迟时间后，消息才会被转移到另一个队列中供消费者消费。延迟队列常用于实现需要延时处理的任务，如定时任务、延迟通知等。优先级队列是一种支持按元素优先级顺序处理消息的队列。在这种队列中，每个消息被赋予一个优先级，高优先级的消息会先于低优先级的消息被消费处理，无论它们的到达顺序如何。优先级队列用于实现重要任务的优先处理等场景。
rabbitmq简介与布署
Q7758521adc的博客
07-16 631
如果队列不存在会被创建 channel.queue_declare(queue='test_queue', durable=True) # 发送消息到队列中 channel.basic_publish( exchange='', routing_key='test_queue', body='Hello, RabbitMQ!从queue里取数据需要具有queue的可读权限。可登陆管理控制台(启用management plugin的情况下)，可查看所有的信息，并且可以对用户，策略(policy)进行操作。
2.RabbitMQ相关概念
最新发布
卷土的博客
07-17 365
RabbitMQ是一个消息中间件，接受并转发消息。它接收、存储和转发消息数据。
【雷丰阳-谷粒商城 】【分布式高级篇-微服务架构篇】【22】【RabbitMQ】
Keep Reading Keep Writing Keep Thinking
07-15 1443
【雷丰阳-谷粒商城 】【分布式高级篇-微服务架构篇】【22】【RabbitMQ】 延时队列，可靠消息 Message Queue 消息队列 异步处理 应用解耦 流量控制 消息中间件概念 RabbitMQ概念 Message Publisher Exchange Queue Binding Connection Channel Consumer Virtual Host Broker RabbitMQ运行机制 AMQP 中的消息路由 Exchange类型 RabbitMQ整合
RabbitMQ 安装
sszdzq的博客
07-16 897
rabbitmq 管理界面无法显示，rabbitmq window 安装
头歌java多线程练习题
06-05
头歌Java多线程练习题是一个用于练习Java多线程编程的项目。这个项目包含了一系列的练习题目，旨在帮助开发者学习和掌握Java多线程的相关知识。 这个项目主要涉及以下几个方面的内容： 1. 线程的创建和启动； 2. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值