精华内容
下载资源
问答
  • 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多线程练习题

    2021-03-22 14:08:37
    两个线程交替打印1212121212这使用了原子的一个状态类表示当前可执行的线程。/*** @Author: tjc* @description* @Date Created in 14:35 2021-03-03* 两个线程交替打印1212121212*/public class Demo6 {public ...

    两个线程交替打印1212121212

    这题使用了原子的一个状态类表示当前可执行的线程。

    /**

    * @Author: tjc

    * @description

    * @Date Created in 14:35 2021-03-03

    * 两个线程交替打印1212121212

    */

    public class Demo6 {

    public static void main(String[] args) {

    AtomicInteger i = new AtomicInteger(0);

    new Thread(new Print1(i)).start();

    new Thread(new Print2(i)).start();

    }

    }

    class Print1 implements Runnable{

    private AtomicInteger i;

    public Print1(AtomicInteger i) {

    this.i = i;

    }

    public void run() {

    while(true) {

    if(i.get() == 0) {

    System.out.print("1");

    i.compareAndSet(0, 1);

    }

    }

    }

    }

    class Print2 implements Runnable{

    private AtomicInteger i;

    public Print2(AtomicInteger i) {

    this.i = i;

    }

    public void run() {

    while(true) {

    if(i.get() == 1) {

    System.out.print("2");

    i.compareAndSet(1, 0);

    }

    }

    }

    }

    通过 N 个线程顺序循环打印从 0 至 100

    /**

    * @Author: tjc

    * @description

    * @Date Created in 16:05 2021-03-03

    * 通过 N 个线程顺序循环打印从 0 至 100

    */

    public class Demo3 {

    public static void main(String[] args) {

    AtomicInteger curThread = new AtomicInteger(1);

    AtomicInteger count = new AtomicInteger(0);

    new Thread(new PrintTask(1, 5, curThread, count)).start();

    new Thread(new PrintTask(2, 5, curThread, count)).start();

    new Thread(new PrintTask(3, 5, curThread, count)).start();

    new Thread(new PrintTask(4, 5, curThread, count)).start();

    new Thread(new PrintTask(5, 5, curThread, count)).start();

    }

    }

    class PrintTask implements Runnable {

    private AtomicInteger count;

    private int no;

    private int maxNum;

    private AtomicInteger curThread;

    private boolean start = true;

    public PrintTask(int no, int maxNum, AtomicInteger curThread, AtomicInteger count) {

    this.no = no;

    this.maxNum = maxNum;

    this.count = count;

    this.curThread = curThread;

    }

    public void turn() {

    if (curThread.get() >= maxNum) {

    curThread.set(1);

    } else {

    curThread.incrementAndGet();

    }

    }

    public void run() {

    while (start) {

    synchronized (curThread) {

    while (no != curThread.get()) {

    try {

    curThread.wait();

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    }

    turn();

    if (count.get() > 100) {

    start = false;

    curThread.notifyAll();

    break;

    }

    System.out.println("thread" + no + ": " + count.get());

    count.getAndIncrement();

    curThread.notifyAll();

    }

    }

    System.out.println("thread" + no + " end.");

    }

    }

    展开全文
  • JAVA多线程练习题的答案。都是一些基本的练习题。对初学者有帮助
  • java基础之多线程练习题,博客访问地址: http://blog.csdn.net/u014028392/article/details/76906801
  • 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多线程习题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++...

    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++) {
    //           char a=(char) i;
    //            System.out.println(a);
    //        }
            for (char c = 'a'; c < 'z'; c++) {
                System.out.println(c);
            }
        }
    }
    
    package week3.day4.zy1;
    
    public class MyThread2 extends  Thread{
    
        @Override
        public void run() {
    
            for (int i = 65; i < 91; i++) {
                char a=(char) i;
                System.out.println(a);
            }
        }
    }
    
    package week3.day4.zy1;
    
    
    public class zy1 {
        public static void main(String[] args) {
            MyThread1 t1=new MyThread1();
            MyThread2 t2=new MyThread2();
    
            t1.start();
            t2.start();
        }
    }
    

    2.编写一个有两个线程的程序,第一个线程用来计算2~100000之间的奇数的个数,第二个线程用来计算100000~200000之间的偶数的个数,最后输出结果。

    public class Thread1 extends Thread{
        int num1=0;
        @Override
        public void run() {
            for (int i = 2; i < 1000001; i++) {
                if(i%2==0){
                    num1++;
                }
            }
            System.out.println("偶数:"+num1);
        }
    }
    
    public class Thread2 extends Thread{
        int num2=0;
        @Override
        public void run() {
            for (int i = 2; i < 1000001; i++) {
                if(i%2!=0){
                    num2++;
                }
            }
            System.out.println("偶数:"+num2);
        }
    }
    public class zy2 {
        public static void main(String[] args) {
            Thread1 t1=new Thread1();
            Thread2 t2=new Thread2();
    
            t1.start();
            t2.start();
        }
    }

    3、使用多线程,模拟龟兔赛跑的场景。

    public class Rabbit extends   Thread{
        @Override
        public void run() {
    
            int  length=0;
    
            while(true){
                //跑
                length+=3;
    
                try {
                    Thread.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
    
                if(length>=100){
                    break;
                }
            }
            System.out.println("rabbit  end");
        }
    }
    package week3.day4.lx;
    
    public class Tortoise extends   Thread{
    
        @Override
        public void run() {
    
            int  length=0;
    
            while(true){
                //跑
                length+=1;
    
                if(length>=100){
                    break;
                }
            }
            System.out.println("tortoise  end");
    
        }
    }
    
    package week3.day4.lx;
    
    public class Test3 {
    
        public static void main(String[] args) {
    
            System.out.println("预备,跑");
    
            Tortoise  t=new Tortoise();
            t.start();
    
            Rabbit   r=new Rabbit();
            r.start();
    
        }
    }
    

    4.使用多线程实现多个文件同步复制功能,并在控制台显示复制的进度,进度以百分比表示。例如:把文件A复制到E盘某文件夹下,在控制台上显示“XXX文件已复制10%”,“XXX文件已复制20%”……“XXX文件已复制100%”,“XXX复制完成!”

    package week3.day4.zy4;
    
    import java.io.*;
    
    public class Thread1 extends Thread{
        private File oldFile;
        private File newFile;
    
        public Thread1(String oldFile, String newFile) {
            this.oldFile = new File(oldFile);
            this.newFile = new File(newFile);
        }
    
        @Override
        public void run() {
             FileInputStream in=null;
            FileOutputStream out=null;
            try {
                 in=new FileInputStream(oldFile);
                 out=new FileOutputStream(newFile);
                double length=oldFile.length();
                double now=0;
                int a=1;
                byte[] b=new byte[1];
                int i=in.read(b);
                while (i!=-1){
                    now+=i;
                    out.write(b);
                    i=in.read(b);
                    if (now>length*(a*0.1)){
                        System.out.println("文件复制了"+oldFile.getName()+a*10+"%");
                        a++;
                    }
                }
                System.out.println(oldFile.getName()+"复制完成");
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                out.close();
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
    }
    
    package week3.day4.zy4;
    
    import java.io.File;
    
    //使用多线程实现多个文件同步复制功能,并在控制台显示复制的进度,进度以百分比表示。
    // 例如:把文件A复制到E盘某文件夹下,在控制台上显示“XXX文件已复制10%”,“XXX文件已复制20%”……“XXX文件已复制100%”,“XXX复制完成!”
    public class zy4 {
        public static void main(String[] args) {
            Thread1 t1=new Thread1("C:\\Users\\lenovo\\Desktop\\1.txt","C:\\Users\\lenovo\\Desktop\\2.txt");
            Thread1 t2=new Thread1("C:\\Users\\lenovo\\Desktop\\3.txt","C:\\Users\\lenovo\\Desktop\\4.txt");
            t1.start();
            t2.start();
        }
    }
    

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

    2022-04-29 01:54:28
    import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * 题目:两个储户分别向同一个帐户存3000元,每次存1000,存三次。每次存完打印账户余额。 * * @author Cao ...
  • Java多线程习题Java多线程习题
  • 多线程练习题java

    2015-11-09 22:08:03
    java多线程初学者练习题目,供初学者练习使用
  • java多线程编程练习题精品文档2016全新精品资料-全新公文范文-全程指导写作 –独家原创 PAGE1 / NUMPAGES1 java多线程编程练习题 [] 选择题1.编写线程类,要继承的父类是:A:ObjectB:RunnableC:SerializableD: ...
  • JAVA多线程练习题

    2011-04-12 22:54:32
    JAVA多线程练习题。都是一些基本的练习题。对初学者有帮助
  • //线程休眠 } catch (InterruptedException e) { e.printStackTrace(); } } } public synchronized boolean svel() { if (count ) { return false; } i++; count--; System.out.println(Thread.currentThread()....
  • java线程练习题及答案

    2021-03-05 20:11:55
    java线程练习题及答案 线程与线程类 1 线程的概念 线程的概念来源于计算机的操作系统的进程的概念。进程是一个程序关于某个数据集 的一次运行。也就是说,进程是运行中的程序,是程序的一次运行活动。 线程和进程的...
  • 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创建线程第一种创建线程的方式第二种创建线程的方式分析两种线程的创建线程的优先级优先级设置以及获取优先级的方法线程的生命周期图解线程的生命周期(参考尚硅谷...
  • java多线程基础知识练习题,选择题及代码题。适合初学者
  • java多线程--练习题总结

    千次阅读 多人点赞 2018-10-25 14:01:45
    练习题2:设计四个线程,其中两个线程每次对变量i加1,另外两个线程每次对i减1. 练习题3:自己编写代码,实现生产者-消费者模型功能.内容自由发挥,只需要表达思想. 练习题4:现在有T1、T2、T3三个线程,你怎样保证T2在...
  • 本关任务:利用多线程相关知识控制三个线程,依照先后顺序顺序输出。 相关知识(略) 编程要求 请仔细阅读右侧代码,在 Begin-End 区域内进行代码补充,使线程依照先后顺序依次输出JavaThread+线程名。 提示:我们...
  • 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
收藏数 16,478
精华内容 6,591
关键字:

java多线程练习题

java 订阅