精华内容
下载资源
问答
  • java多线程习题
    2021-08-20 08:31:12
    //练习题
     //生产者(Producer) 将产品交给店员(Clerk) 而消费者(Customer)从店员处取走商品
     // 店员一次只能持有固定数量的产品(比如20) 如果生产者试图生产更多的产品
     // 店员会叫生产者停一停 如果店中有空位 再通知生产者 继续生产
     // 如果店中没有了产品 店员会告诉消费者等一下
     // 如果店中有了产品 再通知消费者取走产品
     // 分析1. 是否是多线程问题 ? 是 生产者线程 消费者线程
     // 2. 是否有共享数据? 是 店员(或产品)
     // 3. 如何解决线程安全问题?
     // 4. 是否涉及到线程通信? 是
    
     Clerk clerk = new Clerk();
     Producer producer = new Producer(clerk);
     Customer customer = new Customer(clerk);
     Thread thread2 = new Thread(producer);
     Thread thread3=new Thread(customer);
     Thread thread4=new Thread(producer);
     thread2.setName("生产者1");
     thread3.setName("消费者1");
     thread4.setName("生产者2");
     thread2.start();
     thread4.start();
     thread3.start();

    package com.day7.test;
    
    /**
     * User: Json
     * Date: 2021/8/20
     * 生产者
     **/
    public class Producer implements  Runnable{
        private Clerk clerk;
        public Producer(Clerk clerk){
            this.clerk=clerk;
        }
        @Override
        public void run() {
            while (true){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.clerk.pro();
            }
    
        }
    }
    

    package com.day7.test;
    
    /**
     * User: Json
     * Date: 2021/8/20
     * 店员
     **/
    public class Clerk {
          private int num=0;
    
        //生产商品
        public synchronized void pro(){
    
                if(num<20){
                    num++;
                    System.out.println(Thread.currentThread().getName()+"生产的第"+num+"产品");
                    notify();
                }else{
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
    
    
        }
    
        //消费商品
        public synchronized void Cus(){
    
                if(num>0){
                    System.out.println(Thread.currentThread().getName()+"消费了第"+num+"个产品");
                    num--;
                    notify();
                }else{
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
    
        }
    
    
    }
    

    package com.day7.test;
    
    /**
     * User: Json
     * Date: 2021/8/20
     * 消费者
     **/
    public class Customer implements Runnable{
        private Clerk clerk;
        public Customer(Clerk clerk){
            this.clerk=clerk;
        }
        @Override
        public void run() {
            while (true){
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.clerk.Cus();
            }
    
    
        }
    
    
    }
    
    更多相关内容
  • JAVA多线程练习题的答案。都是一些基本的练习题。对初学者有帮助
  • java 多线程练习题

    千次阅读 2019-06-18 11:11:57
    * 设计一个多线程的程序如下:设计一个火车售票模拟程序。假如火车站要有100张火车票要卖出,现在有5个售票点同时售票,用5个线程模拟这5个售票点的售票情况。 * */ public class Test1 { public static void ...
    package study_04;
    /*
     * 设计一个多线程的程序如下:设计一个火车售票模拟程序。假如火车站要有100张火车票要卖出,现在有5个售票点同时售票,用5个线程模拟这5个售票点的售票情况。
     * 
     */
    public class Test1 {
    	public static void main(String[] args) {
    		Ticket ticket = new Ticket();
    		new Thread(new ticketOffice(ticket,11),"售票点1").start();
    		new Thread(new ticketOffice(ticket,22),"售票点2").start();
    		new Thread(new ticketOffice(ticket,33),"售票点3").start();
    		new Thread(new ticketOffice(ticket,19),"售票点4").start();
    		new Thread(new ticketOffice(ticket,21),"售票点5").start();
    	}
    }
    
    
    //火车站
    class Ticket{
    	public int available = 100;//总票数
    	public Ticket() {
    
    	}
    	public boolean isTicket(int ticketBuy) {//
    		if (ticketBuy > available) {
    			return false;
    		}else {
    			available -= ticketBuy;
    			return true;
    		}
    	}
    }
    //代售点
    class ticketOffice implements Runnable{
    	
    	Ticket ticket;//火车站
    	int ticketBuy;//想购买的票数
    		
    	public ticketOffice(Ticket ticket, int ticketBuy) {
    		this.ticket = ticket;
    		this.ticketBuy = ticketBuy;
    	}
    
    	@Override
    	public void run() {
    		try {
    			Thread.sleep(100);
    		} catch (InterruptedException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		synchronized (ticket) {
    			boolean flag = ticket.isTicket(ticketBuy);
    			if (flag) {
    				System.out.println(Thread.currentThread().getName() + "想要购票" +ticketBuy+ "---------->购票成功 剩余" + ticket.available);
    			}else {
    				System.out.println(Thread.currentThread().getName() + "想要购票" +ticketBuy+ "---------->失败");
    			}
    		}
    		
    	}
    }
    
    
    package study_04;
    /*
     * 2. 编写两个线程,一个线程打印1-52的整数,另一个线程打印字母A-Z。打印顺序为12A34B56C….5152Z。即按照整数和字母的顺序从小到大打印,并且每打印两个整数后,打印一个字母,交替循环打印,直到打印到整数52和字母Z结束。
    
          要求:
    
          1) 编写打印类Printer,声明私有属性index,初始值为1,用来表示是第几次打印。
    
          2) 在打印类Printer中编写打印数字的方法print(int i),3的倍数就使用wait()方法等待,否则就输出i,使用notifyAll()进行唤醒其它线程。
    
          3) 在打印类Printer中编写打印字母的方法print(char c),不是3的倍数就等待,否则就打印输出字母c,使用notifyAll()进行唤醒其它线程。
    
          4) 编写打印数字的线程NumberPrinter继承Thread类,声明私有属性private Printer p;在构造方法中进行赋值,实现父类的run方法,调用Printer类中的输出数字的方法。
    
          5) 编写打印字母的线程LetterPrinter继承Thread类,声明私有属性private Printer p;在构造方法中进行赋值,实现父类的run方法,调用Printer类中的输出字母的方法。
    
          6) 编写测试类Test,创建打印类对象,创建两个线程类对象,启动线程。
     */
    public class Test2 {
    	public static void main(String[] args) {
    		Printer p = new Printer();
    		new Thread(new NumberPrinter(p)).start();
    		new Thread(new LetterPrinter(p)).start();
    	}
    }
    
    
    //打印类
    class Printer {
    	private int index = 1;//表示第几次打印
    	//打印数字
    	public synchronized void print(int i) {
    		while (index % 3 == 0) {
    			try {
    				this.wait();
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    		System.out.println("输出数字:" + i);
    		index ++;
    		this.notifyAll();
    	}
    	//打印字母
    	public synchronized void print(char c) {
    		while (index % 3 != 0) {
    			try {
    				this.wait();
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    		System.out.println("输出字符:" + c);
    		index ++;
    		this.notifyAll();
    	}
    }
    
    //数字打印
    class NumberPrinter extends Thread{
    	private Printer p;
    	
    	public NumberPrinter(Printer p) {
    		this.p = p;
    	}
    
    	@Override
    	public void run() {
    		int n = 1;
    		while (1 <= 52) {
    			p.print(n);
    			n++;
    		}
    	}
    }
    
    //字母打印
    class LetterPrinter extends Thread{
    	private Printer p;
    	
    	public LetterPrinter(Printer p) {
    		this.p = p;
    	}
    
    	@Override
    	public void run() {
    		char c = 'A';
    		while (c <= 'Z') {
    			p.print(c);
    			c++;
    		}
    	}
    }
    
    
    
    
    
    package study_04;
    /*
     *  编写多线程程序,模拟多个人通过一个山洞的模拟。这个山洞每次只能通过一个人,每个人通过山洞的时间为5秒,有10个人同时准备过此山洞,显示每次通过山洞人的姓名和顺序。
     */
    public class Test3 {
    	public static void main(String[] args) {
    		Hole hole = new Hole();
    		for (int i = 0; i < 10; i++) {
    			new Thread(new People(hole),"爬洞" + i).start();
    		}
    	}
    }
    
    //洞
    class Hole{
    	public int order = 0;//初始化顺序
    
    	public Hole() {
    		// TODO Auto-generated constructor stub
    	}
    	
    	
    }
    
    //人
    class People implements Runnable{
    	Hole hole;
    	
    	public People(Hole hole) {
    		this.hole = hole;
    	}
    
    	@Override
    	public void run() {
    		synchronized (hole) {
    			try {
    				Thread.sleep(5000);//爬洞时间
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    			System.out.println(Thread.currentThread().getName() + "----->穿过山洞----->顺序为" + ++hole.order);
    		}
    	}
    
    	
    }
    爬洞0----->穿过山洞----->顺序为1
    爬洞8----->穿过山洞----->顺序为2
    爬洞9----->穿过山洞----->顺序为3
    爬洞7----->穿过山洞----->顺序为4
    爬洞5----->穿过山洞----->顺序为5
    爬洞6----->穿过山洞----->顺序为6
    爬洞3----->穿过山洞----->顺序为7
    爬洞4----->穿过山洞----->顺序为8
    爬洞2----->穿过山洞----->顺序为9
    爬洞1----->穿过山洞----->顺序为10
    

     

    展开全文
  • Java多线程练习题.docx

    2020-04-05 11:13:51
    Java多线程习题 一选择 什么原因可导致线程停止执行( ) 线程调用了wait)方法 线程调用了yield)方法 线程调用了pause)方法 线程调用了sleep)方法 哪个方法是实现Runnable接口所需的( ) A. wait) Brun) Cstop) D...
  • Java多线程练习题

    热门讨论 2008-11-21 09:00:27
    这是对Java多线程的一些相关练习题 包括选择 填空 简答 编程等题型
  • 使用多线程,继承Runnable 2.成员变量:生产手机的总数、每个员工生产了多少(用数组存储)、taskName代表生产的手机型号 3.构造器 4.printNo1() 打印第一名的方法 5.delay(int ms)延时的方法 6.run方法:每个工人的...

     

    目录

    一.题目:

    二.思路:

    PhoneTask

    主函数:

    三.参考代码


    一.题目:

    有一个制造手机工厂,根据订单来安排人员生产。
    现在有以下的订单:
    [1] 1000台, Sumsung 手机。
    [2] 500台,iPhone手机。
    [3] 880台,小米手机。
    [4] 1800台,Nodia手机。
    [5] 1400台,黑莓手机。
    工厂请的都是临时工,每生产完一批订单,
    又重新请一批人,随机生成人数(5-15人左右)。
    每个人的生产效率也是不一样的。
    打印每批工人的生产冠军(产量第-一)。

    二.思路:

    PhoneTask

    1.使用多线程,继承Runnable

    2.成员变量:生产手机的总数、每个员工生产了多少(用数组存储)、taskName代表生产的手机型号

    3.构造器

    4.printNo1() 打印第一名的方法

    5.delay(int ms)延时的方法

    6.run方法:每个工人的线程名是自己命名的,假设命名为:worker1,worker2....

     用replace()方法获得索引号:1,2,3....

    把索引号转为int类型

    这样就可以通过produces【索引号】来知道是第几个工人了

    用随机数来随机决定延时多久,也就是某个工人做多久

    7.同步锁(定义一个taskName代表生产的手机型号):剩余量-1,某个工人生产数+1

    主函数:

    1.定义一个订单类,构造方法中获得taskName,count

    2.创建订单对象,调用main函数中的prodece(order1)方法

    3.prodece(Order order)

    (1)使用随机数生成工人数 5-8

    (2)生成任务

    (3)生成线程:使用数组和循环

    (4)创建及开启线程:循环 start()

    (5)等待所有人线程执行完成:循环  join()

    (6)打印第一名

    三.参考代码

    package com.gongsi.cn.test7;
    //手机工厂
    public class PhoneTask implements Runnable{
    
    	//成员变量
    	private int count;//当前任务的任务量(手机总数)
    	private int[] produces ;//每个工人的生产数
    	private String taskName;
    	
    	//构造器
    	public PhoneTask(String taskName,int count,int workerCnt) {
    		this.taskName=taskName;
    		this.count=count;
    		//下标从1开始算
    		this.produces=new int[workerCnt+1];
    		
    	}
    
    	@Override
    	public void run() {
    		//每个工人的线程名是这样命名的(创建线程的时候自己命名的):worker1,worker2......
    		String name=Thread.currentThread().getName();
    		//获取索引号 1,2,3.... 
    		String n=name.replace("worker", "");
    		//转为int类型
    		int no=Integer.valueOf(n);
    		while (count>0) {
    			//生成速度 10-20ms
    			int speed = (int) ((Math.random()*11)+10);
    			delay(speed);
    			synchronized (taskName) {
    				count--;//剩余量-1
    				produces[no]++;//某个工人生产数+1
    			}
    		}
    		
    	}
    	
    	//打印第一名:不含并列第一名
    	public void printNo1() {
    		int max=0;
    		int maxId=0;
    		for (int i = 0; i < produces.length; i++) {
    			System.out.println(i+"生产数:"+produces[i]);
    			if (max<produces[i]) {
    				maxId=i;
    				max=produces[i];
    			}
    		}
    		System.out.println("产量冠军是工人"+maxId+",产量:"+max);
    	}
    	
    	//延时
    	public void delay(int ms) {
    		try {
    			Thread.sleep(ms);
    		} catch (InterruptedException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    	
    
    }
    
    package com.gongsi.cn.test7;
    
    public class TestMain {
    	public static void main(String[] args) throws Exception {
    		Order order1=new Order("红米K30,105");
    		prodece(order1);
    	}
    
    	  static void prodece(Order order) throws Exception {
    		//生成工人数 5-8
    		int workCnt=(int) ((Math.random()*4)+5);
    		
    		//生成任务
    		PhoneTask task=new PhoneTask(order.taskName, order.count, workCnt);
    		
    		//生成线程 有多少个工人就有多少个线程
    		Thread[] ths=new Thread[workCnt+1];
    		for (int i = 0; i <=workCnt; i++) {
    			ths[i]=new Thread(task,"worker"+i);
    		}
    		//创建及开启线程
    		for (int i = 0; i < workCnt; i++) {
    			ths[i].start();
    		}
    		
    		//等待所有人线程执行完成
    		for (int i = 0; i < workCnt; i++) {
    			ths[i].join();//等待
    		}
    		
    		//打印第一名
    		task.printNo1();
    	}
    
    }
    
    //订单类
    class Order{
    	public String taskName;
    	public int count;
    	public Order(String c) {
    		String[] date=c.split(",");
    		taskName=date[0];
    		count=Integer.valueOf(date[1]);
    	}
    }

    不知道为什么它还是从0开始.....

    展开全文
  • 多线程——java练习题

    2022-04-29 01:54:28
    import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * 题目:两个储户分别向同一个帐户存3000元,每次存1000,存三次。每次存完打印账户余额。 * * @author Cao ...
    package com.chang.exer;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    /**
     * 题目:两个储户分别向同一个帐户存3000元,每次存1000,存三次。每次存完打印账户余额。
     *
     * @author Cao Longchang
     * @create 2022-04-28 20:15
     */
    
    // 测试类
    public class AccountTest {
        public static void main(String[] args) {
            Customer c1 = new Customer("甲", 3000);
            Customer c2 = new Customer("乙", 5000);
    
            Thread t1 = new Thread(c1);
            Thread t2 = new Thread(c2);
    
            t1.start();
            t2.start();
        }
    }
    
    // 账户类
    class Account {
        private static float balance = 0F;
    
        public static float getBalance() {
            return balance;
        }
    
        public static void setBalance(float balance) {
            Account.balance = balance;
        }
    }
    
    //储户类
    class Customer implements Runnable {
        private String name;
        private float balance;
    
        public Customer(String name, float balance) {
            this.name = name;
            this.balance = balance;
        }
    
        @Override
        public void run() {
            for (int i = 0; i < 3; i++) {
                deposit(1000);
    
                //强制阻塞,增大线程交替执行的概率
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
        // 创建Lock对象
        static Lock lock = new ReentrantLock();
    
        // 创建存钱方法,并使用Lock锁方式保证线程安全
        void deposit(float money) {
            try {
                lock.lock();
            if (money <= balance) {
                float b1 = Account.getBalance() + money;
                balance -= money;
    
                //强制阻塞,增大不安全概率
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
    
                Account.setBalance(b1);
                System.out.println(this.name + "存钱成功,余额为:" + b1);
            } else {
                System.out.println(this.name + "对不起,余额不足,请充值!");
            }
            } finally {
                lock.unlock();
            }
        }
    }
    
    展开全文
  • java基础之多线程练习题,博客访问地址: http://blog.csdn.net/u014028392/article/details/76906801
  • java多线程习题01

    2022-03-11 10:46:47
    1、编写两个线程,一个打印a-z,一个打印A-Z。 //1、编写两个线程,一个打印a-z,一个打印A-Z。 public class MyThread1 extends Thread { @Override public void run() { // for (int i = 97; i <123; i++...
  • 多线程练习题java

    2015-11-09 22:08:03
    java多线程初学者练习题目,供初学者练习使用
  • Java多线程习题Java多线程习题
  • JAVA多线程练习题

    2011-04-12 22:54:32
    JAVA多线程练习题。都是一些基本的练习题。对初学者有帮助
  • java多线程练习题

    2019-05-06 20:58:20
    1.使用多线程,模拟龟兔赛跑的场景。 package lianxi1; class Rabbit extends Thread{ int i; @Override public void run() { for ( i=0;i<=1000;i+=100) { System.out.println("兔子跑了...
  • Java多线程练习

    2021-04-03 11:55:40
    Java多线程线程类的部分方法有关方法1有关方法而2创建线程第一种创建线程的方式第二种创建线程的方式分析两种线程的创建线程的优先级优先级设置以及获取优先级的方法线程的生命周期图解线程的生命周期(参考尚硅谷...
  • 模拟一个人生产50个玩具,每200毫秒生产一个,当生产到第20个时加入每秒吃1个馒头,共吃完3个后在接着生产的多线程。 代码如下: /** * 模拟一个人生产50个玩具,每200毫秒生产一个,当生产到第20个时加入每秒 * ...
  • Java多线程面试以及答案整理【最新版】Java多线程高级面试大全(2021版),发现网上很多Java多线程面试都没有答案,所以花了很长时间搜集,本套Java多线程面试大全,汇总了大量经典的Java多线程程序员面试...
  • java多线程面试选择大全含答案1.下面程序的运行结果()(选择一项)public static void main(String[] args) {Thread t=new Thread(){public void run(){pong();}};t.run();System.out.println("ping");}static ...
  • java多线程编程练习题精品文档2016全新精品资料-全新公文范文-全程指导写作 –独家原创 PAGE1 / NUMPAGES1 java多线程编程练习题 [] 选择题1.编写线程类,要继承的父类是:A:ObjectB:RunnableC:SerializableD: ...
  • Java在语言层面对多线程提供了卓越的支 持,它也是一个很好的卖点。 2) 线程和进程有什么区别? 线程是进程的子集,一个进程可以有很多线程,每条线程并行执行不同的任务。不同的进程使用不同的内存空间,而所有的...
  • Java多线程练习

    2021-04-26 14:16:59
    Java多线程练习 在main方法中使用三个线程,向一个List集合中按顺序添加1到10共十个数字,添加完成后在控制台打印这个List的值(应该是[1,2,3,4,5,6,7,8,9,10]),然后结束程序执行。 import java.util.ArrayList; ...
  • java线程练习题

    2021-08-21 16:18:47
    两个线程打印ABC 1.两个线程打印ABC public class NameList { private List names = new ArrayList(); public synchronized void add(String name) { names.add(name); } public synchronized void printAll()...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,708
精华内容 7,083
关键字:

java多线程习题