Java实现多线程售票

最新推荐文章于 2023-10-09 14:30:23 发布
最新推荐文章于 2023-10-09 14:30:23 发布
阅读量355 收藏 4
点赞数
分类专栏： # Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43573663/article/details/107799579
版权

文章目录

Synchronized和Lock的区别是什么？

1.synchronized是Java中的关键字，是jdk自带的；Lock是一个接口
2.synchronized在线程执行发生异常时，jvm会让线程释放锁，因此不会导致死锁现象发生；Lock在finally中必须通过unLock()去释放锁，不然容易造成线程死锁
3.使用synchronized时，如果A线程阻塞，B线程会一直等待，不能够响应中断；Lock可以尝试获得锁，线程可以不用一直等待，通过interrupt()方法能够响应中断（interrupt无法中断已经获取的锁，只能中断等待状态）
4.synchronized无法判断锁的状态；Lock可以知道有没有成功获取锁（可以通过其中的tryLock()等自带的多个方法去尝试获取锁）

在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当多线程竞争资源非常激烈时，此时Lock的性能要远远优于synchronized。具体使用时要根据适当情况选择。

案例一

方法一 继承Thread类

package sell;

import java.lang.Thread;

public class SaleSysTest {

	public static void main(String[] args) {
		
		//创建5个线程，传入线程名[001]、[002]...并开启
		for(int i=1;i<6;i++) {
			new SaleThread("[00"+i+"]").start();
		}
	}

}

class SaleThread extends Thread{
	
	//车票数被共享，所以定义为static，数量为50.
	private static int ticket=50;
	//通过锁来保证线程不会重复访问
	private static Object obj=new Object();
	
	//有参构造传入线程名
	public SaleThread(String name) {
		// TODO Auto-generated constructor stub
		super(name);
	}
	//无参构造传入线程名
	public SaleThread() {
		
	}
	
	//重写run()方法，将售票动作放入其中
	public void run() {
		while(true) {
			//在锁外使用sleep(),以便于更好的解决复现问题
			try {
					Thread.sleep(100);
			}catch(InterruptedException e) {
				e.printStackTrace();
			}
			//使用synchronized需要锁统一资源,不然没效果,所以将obj初始化为static静态。
			//但让也可以使用字符串 synchronized("lock");lock随便输入
			synchronized(obj) {
				//还有余票---出票
				if(ticket>0) {
					System.out.println(Thread.currentThread().getName()+"号窗口第"+ticket+"票 正在出票...");
					ticket--;
				}else {
					//车票售罄
					System.out.println("车票已售罄，下次请趁早...");
					//退出
					System.exit(0);
				}
			}
		}
	}
}

方法二 实现Runnable接口

package sell;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

class Selldemolist implements Runnable {
	Scanner in=new Scanner(System.in);
    int tickets=in.nextInt();
    private int salenum=0;
    
    public void sellTickets() {	
        synchronized (this) {
            if (tickets > 0) {
            tickets--;
            salenum++;
            System.out.println(Thread.currentThread().getName() + "已经购买编号为"+salenum+"的票");
            Date date=new Date();
			SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			String time=sdf.format(date);
            System.out.println("出票时间为："+time);
            try {
            	Thread.sleep(500);
			} catch (InterruptedException e) {	
				e.printStackTrace();
			}
            System.out.println("___________________________________");
            System.out.println("                                     ");
            }
        }
    }
 public void run() {
        while (tickets > 0) {
            sellTickets();
            try {
               
                Thread.sleep(400);
                if(tickets==0){
                System.out.println("非常抱歉，售票已经结束,请明天再来！");
                 System.exit(-1);
                
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
        }
    }
    
}

public  class  Selldemo1 {
	public static void main(String[] args) {
		Selldemolist ticket=new Selldemolist();
		Thread mary = new Thread(ticket,"玛丽");
		Thread jack = new Thread(ticket,"杰克");
		Thread rose=new Thread(ticket,"柔丝");
		Thread black=new Thread(ticket,"布莱克");
		mary.start();
		jack.start();
		rose.start();
		black.start();
	}
}

案例二

方法一 继承Thread类

package Demo;

public class Sellticket1 {
	public static void main(String[] args) {
		
		//创建3个线程，并开启
		for(int i=1;i<4;i++){
			new TicketWindow("窗口"+i+"：").start();
		}
		
	}
}

  //方法1.继承Thread类
class TicketWindow extends Thread{

	private static int ticket = 100;//车票数被共享,所以定义为static	
	private static Object obj = new Object();//通过锁来保证线程不会重复访问
	
	//有参构造传入线程名
	public TicketWindow(String name) {
		super(name);
	}
	
	public TicketWindow() {
		
	}

	//重写run()方法，将售票动作放入其中
	public void run() {
		while (true) {
			//在锁外使用sleep( )；以便于更好的解决复现问题
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
			//也可以使用字符串 synchronized("lock");lock随便输入
			synchronized (obj) {			
				if (ticket > 0) {
					System.out.println(Thread.currentThread().getName() + "第-- "+ ticket + " --票正在出票...");
					ticket--;
				} else {					
					System.out.println("票已售完   下次再见！！");
					System.exit(0);
				}
			}
		}
	}	
}

方法二 实现Runnable接口

package Demo;

public class Sellticket2 {
	public static void main(String[] args) {
		
		Windows sc = new Windows();
		//创建3个线程，并开启
		for(int i=1;i<4;i++){
			new Thread(sc,"窗口"+i).start();
		}

	}	
}

//方法2.实现Runnable接口
class Windows implements Runnable{
	
    private int ticket = 100;  
    private Object obj = new Object(); //定义一个线程同步对象
    
    public void run() {        
        while(true){
 			 try {
                Thread.sleep(50);
              } catch (InterruptedException e) {
                 e.printStackTrace();
              }
 			 
            //同步锁
            synchronized(obj){
                if(ticket > 0){
                    System.out.println(Thread.currentThread().getName()+" 售出第-- "+ticket +" --张票");
                    ticket--;
                }else{
                    System.out.println("票已售完   下次再见！！");
                    System.exit(0);
                }
            }
        }       
    }
}

案例三

方法一 继承Thread类

package xiancheng;

import java.util.Scanner;

class thread extends Thread {
	public static int num, num1;
	public static Object obj = new Object();
	public int i = 1;
	public thread(String name) {
		super(name);
	}
	public thread() {
	}
	@Override
	public void run() {
		// TODO 自动生成的方法存根
		while(true) {
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
			synchronized(obj) {
				if(num > 0) {
					System.out.println("售票点：" + Thread.currentThread().getName() + "  当前卖出票号：" + (num1 - num + 1) );
					num--;
				} else {
					System.out.println("已卖完");
					System.exit(0);
				}
			}
		}
	}
	public void getChePiao(int chePiao) {
		num = chePiao; 
		num1 = chePiao;
	}
}

public class DoThread {
	
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int i;
		Scanner scanner = new Scanner(System.in);
		System.out.print("请问要卖多少张票：");
		new thread().getChePiao(scanner.nextInt());
		for(i = 1 ; i <= 4 ; i++) {
			new thread("" + i).start();
		}
	}

}

方法二 实现Runnable接口

package xiancheng;

import java.util.Scanner;

class Runn implements Runnable {
	public int num, i = 1, num1;
	@Override
	public void run() {
		// TODO 自动生成的方法存根
		while(true) {
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
			doRun();
			if(num <= 0) {
				System.exit(0);;
			}
		}
	}
	public synchronized void doRun() {
		if(i > 0 && i <= num1) {
			System.out.println("售票点：" + Thread.currentThread().getName() + "  当前卖出票号：" + i);
			i++;
			num--;
		} else if(num <= 0) {
			System.out.println("已卖完");
			System.exit(0);
		}
	}
	public void getChePiao() {
		Scanner scanner = new Scanner(System.in);
		System.out.print("请问要卖多少张票：");
		num = scanner.nextInt(); 
		num1 = num;
	}
}

public class DoRunnable {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int i;
		Runn runn = new Runn();
		runn.getChePiao();
		for(i = 1 ; i <= 4 ; i++) {
			new Thread(runn, "" + i).start();
		}
	}
}

案例四

方法一 继承Thread类

package one;

import java.util.Scanner;

public class Sale {
	private static int ticket,temp;
	public static void  main(String [] args) {
		
		System.out.println("请输入您发放的票数：");
		Scanner in = new Scanner(System.in);
		String x = in.nextLine();
		ticket = Integer.parseInt(x);
		temp = ticket; 
		for(int i=1;i<6;i++) {
			new sell1(" ["+i+"]",temp).start();
		}
	}
}

class sell1 extends Thread { 
	 private static int ticket,temp1;
	 private static Object obj = new Object();
	 
	 public sell1() {
		 
	 }
	 public sell1(String name,int temp) {
		 
		 super (name);
		 ticket = temp;
	 }
	 @Override
	 public void run() {
		 temp1 = ticket;
		 while (true) {
			 try {
				 Thread.sleep(100);
				 
			 }
			 catch(InterruptedException e) {
				 e.printStackTrace();
			 }
	
			 synchronized (obj) {
				 if(ticket>0) {
					 int a = temp1-ticket+1;
					 System.out.println("售票点："+Thread.currentThread().getName()+ "\t当前票号:   "+a);
					 ticket--;
				 }
				 else {
					 System.out.println("车票已经售完，下次请趁早...");
					 System.exit(0);
				 }
			 }
		 }
	 }
}

方法二 实现Runnable接口

package two;

import java.util.Scanner;

public class Sale2 {
	public static void  main(String [] args) {
		int ticket1;
		System.out.println("请输入您发放的票数：");
		Scanner in = new Scanner(System.in);
		String x = in.nextLine();
		ticket1 = Integer.parseInt(x);
		sell s = new sell(ticket1); 
		for(int i=1;i<6;i++) {
			new Thread(s,"["+i+"]").start();
		}
	}
}

class sell implements Runnable{ 
	 private static int ticket,temp1;
	 private static Object obj = new Object();
	 
	 public sell() {
		 
	 }
	 public sell(int ticket1) {
		 ticket = ticket1;
	 }
	 @Override
	 public void run() {
		 temp1 = ticket; 
		 while (true) {
			 try {
				 Thread.sleep(100);
				 
			 }
			 catch(InterruptedException e) {
				 e.printStackTrace();
			 }
	
			 synchronized (obj) {
				 if(ticket>0) {
					 int a = temp1-ticket+1;
					 System.out.println("售票点："+Thread.currentThread().getName()+ "\t当前票号:   "+a);
					 ticket--;
				 }
				 else {
					 System.out.println("车票已经售完，下次请趁早...");
					 System.exit(0);
				 }
			 }
		 }
	 }
}

案例五

方法一 继承Thread类

package eclipse;

public class Ticket1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		//首先创建5个线程，传入线程名:如[001]、[002]等，并将其开启。
		int i;
		for(i=1;i<+5;i++) {
			new SaleThread("[00"+i+"]").start();
		}
	}

}
class SaleThread extends Thread{
	//由于车票数要对公众共享，所以要定义为静态成员变量，数量定为100.
	private static int ticket=100;
	//通过锁来保证线程都不会被重复访问.
	private static Object obj=new Object();
	//把有参构造传入线程名
	public SaleThread(String name) {
		super(name);
	}
	public SaleThread(){
		
	}

//重新写入run()方法，将售票动作放入其中;
@Override
public void run() {
	while(true) {
		//要在锁外使用sleep();	
try {
	Thread.sleep(100);
	
}catch(InterruptedException e) {
     e.printStackTrace();

	}
	//使用synchronized需要统一资源，不然没效果，所以将obj初始化为static静态.
	//但让也可以使用字符串 synchronized("lock");lock随便输入
synchronized(obj) {
	
	//还有余票——————出票
	if(ticket>0) {
		System.out.println(Thread.currentThread().getName()+"号窗口正在出票...票号:"+ticket);
		ticket--;
	}else {
		//利用if，else语句来看看车票售出的情况，如果售出完成，则执行else下面的语句。
		System.out.println("车票已经售完，下次请趁早买票!");
		System.exit(0);
	}
}
}
}
}

方法二 实现Runnable接口

package eclipse;

public class Ticket2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
//首先得到对象
		SaleSys a =new SaleSys();
		//然后把对象放入线程中
	for(int i=1;i<6;i++) {
		new Thread(a,"[00"+i+"]").start();
	}
	}

}

class SaleSys implements Runnable{
	//定义票的总数
	private int ticket = 100;
	//定义一个线程同步的对象
	private Object obj=new Object();
	
	@Override
	public void run() {
		while(true) {
			try {
				Thread.sleep(50);
			}catch(InterruptedException e) {
				e.printStackTrace();
			}
			//同步锁
			synchronized(obj) {
				if(ticket>0) {
					System.out.println(Thread.currentThread().getName()+"号窗口正在售票...票号:"+ticket);
					ticket--;
				}else {
					System.out.println("票已售完，请下次再来吧!");
					System.exit(0);
		}
		}
		}
	}
}

案例六

方法一 继承Thread类

package com.hym.Threaded;

public class Sale_Thread{
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//创建五个窗口（线程）
		for(int i = 1;i < 6;i++) {
			new SaleThread("[0" + i + "]").start();
	}
	
	}
}
class SaleThread extends Thread{
	//车票数为共享变量，静态变量定义用static,数量为100
	private static int tickets = 100;
	//通过锁使这个线程不会被重复访问
	private static Object obj = new Object();
	public SaleThread(String name) {
		super(name);
	}
	public SaleThread() {
		
}

//重写run方法
@Override
public void run() {
	while(true) {
		try {
			Thread.sleep(200);
		}catch(InterruptedException e){
			e.printStackTrace();
		}
		//将obj初始化为static静态
		synchronized (obj) {
			if(tickets > 0) {
				System.out.println(Thread.currentThread().getName() + "号窗口第" + tickets-- + "票正在出票...");
			}
			else {
				//车票售完
				System.out.println("车票已售罄。");
				System.exit(0);
			}
		}
	}
}
	
}

方法二 实现Runnable接口

package com.hym.Threaded;

public class Test2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		SaleSys s = new SaleSys();
		//创建五个窗口（线程）
		for(int i = 1;i < 6;i++) {
			new SaleThread("[0" + i + "]").start();
		}

	}

}
class SaleSys implements Runnable{
	//车票数为共享变量，静态变量定义用static,数量为100
	private static int tickets = 100;
	//通过锁使这个线程不会被重复访问
	private static Object obj = new Object();

	@Override
	public void run() {
		// TODO Auto-generated method stub
		while(true) {
			try {
				Thread.sleep(200);
			}catch(InterruptedException e){
				e.printStackTrace();
			}
			//将obj初始化为static静态
			synchronized (obj) {
				if(tickets > 0) {
					System.out.println(Thread.currentThread().getName() + "号窗口第" + tickets-- + "票正在出票...");
				}
				else {
					//车票售完
					System.out.println("车票已售罄。");
					System.exit(0);
				}
			}
		
		}
	}
}

案例七

方法一 继承Thread类

package 售票;

public class duo2 {
	public static void main(String[] args) {
		for(int i=1; i<4; i++){
			chuangkou2 sp = new chuangkou2();
			sp.setName(i+"号窗口");
			sp.start();
		}
	}

}
class chuangkou2 extends Thread{
	private int tickets = 10;//车票总量
	
	public void run(){
		while(true){
			if(tickets>0){
				System.out.println(Thread.currentThread().getName() + "准备售票");                    
                tickets--;                                                                                              
                System.out.println(Thread.currentThread().getName() + "卖出一张,剩余票数:" + tickets + "张");
                try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			else{
				System.out.println(Thread.currentThread().getName() + "余票不足,停止售票!");
				break;
			}
		}
	}
}

方法二 实现Runnable接口

package 售票;

public class duo{
	public static void main(String[] args) {
	chuangkou sp = new chuangkou();
	for(int i=1; i<4; i++){
		Thread t = new Thread(sp, i +"号窗口");
		t.start();
	}
}

}
class chuangkou implements Runnable{
	private int tickets = 10;
	
	public void run(){
		while(true){
			if(tickets>0){
				shoupiao();
			}
			else{
				System.out.println(Thread.currentThread().getName() + "余票不足,停止售票!");
				break;
			}
		}
	}
	public synchronized void shoupiao(){
		if(tickets>0){
			System.out.println(Thread.currentThread().getName() + "准备售票");                    
            tickets--;                                                                                              
            System.out.println(Thread.currentThread().getName() + "卖出一张,剩余票数:" + tickets + "张");
            try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

案例八

方法一 继承Thread类

package Thread;


import java.util.Calendar;

import javax.xml.crypto.Data;

import java.util.*;
class sale_Thread extends Thread 
{
	private static volatile int tickets=2000;
	public synchronized void run()
	{
		while(tickets>0)
		{
			use();
		}
	}
	private synchronized static void use()
	{
			if(tickets>0)
			{
				System.out.println(Thread.currentThread().getName() +"售出第"+tickets--+"张票");
			}
//			try {
//				Thread.sleep(200);
//			} catch (InterruptedException e) {
//				// TODO 自动生成的 catch 块
//				e.printStackTrace();
//			}
	}
	public static String getWeekOfDate(Date date) {		
		String[] weekDays = { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };		
		Calendar cal = Calendar.getInstance();		
		cal.setTime(date);		
		int w = cal.get(Calendar.DAY_OF_WEEK) - 1;		
		if (w < 0)			
			w = 0;		
		return weekDays[w];	
		}
	
public static void main(String[] args) {
		Date date=new Date();
		String w=getWeekOfDate(date);
		System.out.println(w);
		String u1="星期五",u2="星期六";
		if(w.equals(u1)||w.equals(u2))
		{
			System.out.println("双休日期间，不予办理业务");
		}
		else
		{
			sale_Thread s1=new sale_Thread();
			sale_Thread s2=new sale_Thread();
			sale_Thread s3=new sale_Thread();
			sale_Thread s4=new sale_Thread();
			sale_Thread s5=new sale_Thread();
			Thread t1=new Thread(s1,"售票窗口1");
			Thread t2=new Thread(s2,"售票窗口2");
			Thread t3=new Thread(s3,"售票窗口3");
			Thread t4=new Thread(s4,"售票窗口4");
			Thread t5=new Thread(s5,"售票窗口5");
			t1.start();
			t2.start();
			t3.start();
			t4.start();
			t5.start();
		}
	}
}

方法二 实现Runnable接口

package Runable;


public class 售票系统2 
{
	public static int tickets=1000;
	protected synchronized static void use()
	{
			if(tickets>0)
			{
				System.out.println(Thread.currentThread().getName() +"售出第"+tickets--+"张票");
			}
//			try {
//				Thread.sleep(200);
//			} catch (InterruptedException e) {
//				// TODO 自动生成的 catch 块
//				e.printStackTrace();
//			}
	}
	public static void main(String[] args) {
		Runner1 runner1 = new Runner1();  
		Runner2 runner2 = new Runner2();  
		Runner3 runner3 = new Runner3();  
        Thread thread1 = new Thread(runner1,"售票窗口1");  
        Thread thread2 = new Thread(runner2,"售票窗口2");  
        Thread thread3 = new Thread(runner3,"售票窗口3"); 
        thread1.start();  
        thread2.start(); 
        thread3.start();
	}
}
class Runner1 extends 售票系统2 implements Runnable { 
     public void run() { 
    	 while(tickets>0)
         use();
    }  
}  
   
class Runner2 extends 售票系统2 implements Runnable { // 实现了Runnable接口，jdk就知道这个类是一个线程  
     public void run() {
    	 while(tickets>0)
    	 use();
    }  
}

class Runner3 extends 售票系统2 implements Runnable { // 实现了Runnable接口，jdk就知道这个类是一个线程  
    public void run() { 
    	while(tickets>0)
    	use();
   }  
}

案例九

方法一 继承Thread类

package Thticket;
/*
 * 继承Thread类方法售票*/
public class MyThread {
	public static void main(String[] args) {
		System.out.println("我是实现系统一");
		for(int i=1;i<6;i++) {
			new saleMyThread("第"+i+"窗口         ").start();
		}
	}
}
	class saleMyThread extends Thread{
		 private static int tic=100;
		//创建锁
		private static Object obj = new Object();
		//有参构造传入线程名
		public saleMyThread(String name) {
			super(name);
		}
		public saleMyThread() {

		}
		@Override
		public void run() {
			// TODO Auto-generated method stub
			while (true) {
				try {
					//0.1秒
					Thread.sleep(100);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				//同步锁
				synchronized (obj) {
					if (tic > 0) {
						System.out.println(Thread.currentThread().getName() + "售出第"
								+ tic + "票");
						tic--;
					}
					else {
						//车票售完
						System.out.println("车票已售完，下次请趁早...");
						System.exit(0);
					}
				}
			}
		}
		
	}

方法二 实现Runnable接口

package Runticket;
/*
 * 实现Runnable接口来售票*/
public class MyRunnable {
	public static void main(String[] args) {
		System.out.println("我是实现系统二");
		//得到对象
		saleMyRunnable mr=new saleMyRunnable();
		for(int i=1;i<6;i++){
        	new Thread(mr,"第"+i+"窗口       ").start();
        }
	}
}
class saleMyRunnable implements Runnable{
		//定义票的总数
	    private int tic = 100;
	    //定义一个线程同步对象
	    private Object obj = new Object();
		@Override
		public void run() {
			// TODO Auto-generated method stub
			while(true) {
				try {
					//0.1秒
					Thread.sleep(100);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				//同步锁
				synchronized(obj) {
					if(tic > 0){
	                    System.out.println(Thread.currentThread().getName()+" 售出第   "+tic +"  张票");
	                    tic--;
	                }else{
	                    System.out.println("票已售完，请下次再来！");
	                    System.exit(0);
	                }
					
				}
			}
		}
	
}
ア灬格子衬衫々
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
自学多线程：使用多线程实现购买商品业务
rw4ta的博客
03-01 1394
自学了几天多线程，写了一个实例，记录一下。 关于多线程实现购买商品业务，我的思路是：购买商品有两步，添加消费记录和减少商品库存，当然正常应用情况下肯定不止这两步，不过测试两步就够了，开两个线程，一条执行添加消费记录，另一条执行减少商品库存。 先搭建一个SSM项目(https://blog.csdn.net/rw4ta/article/details/104522286) 搭建成功后应该是这个样子。...
Java中多线程的使用（二）：消费者抢购商品示例
jack5s的博客
02-19 1402
Java中，多线程的使用大致有两种方式，一个是用Thread类来进行扩展，二是继承IRunnable进行实现，两者底层实现没有区别，基本就是Java中类和接口的区别，由于Java中不能继承多个父类，但能同时继承多个接口，推荐使用IRunnable接口进行实现 ...
多线程+售票案例.docx
05-14
一个程序有多个线程，一个线程中又包含多个进程，在多线程中会有并发问题，这这里讲解了多线程，附有案例帮助理解多线程
多线程
x_xyx的博客
03-13 128
1.什么是进程 真正运行时的程序，才被称为进程。 单核cpu一次只能运行一个进程；宏观并行，微观串行。 2.什么是线程：又称轻量级进程，程序中的一个顺序控制流程，同时也是CPU的基本调度单位。进程又多个线程组成， 彼此间完成不同的工作，交替执行，称为多线程。 例如：迅雷是一个进程，当中的多个下载任务既是多线程。 java虚拟机是一个进程，当中默认包含主线程（mai...
java线程 买东西例子_Java多线程之简单生产者和消费者例子
weixin_36080584的博客
02-27 125
一，在本例子中，有三个类，dataStore(存放数据类)，consumer(消费者)，producer(生产者)。二，看源码例子：类dataStore：import java.lang.InterruptedException;public class dataStore {private int m_iData = 0;private boolean m_bSetData = true;pub...
Java 多线程售票
m0_60979790的博客
12-20 111
Java 多线程实例 火车站售票
Java线程之模拟售票
weixin_42961075的博客
05-07 249
试题：模拟售票系统 要求： 开启三条线程，模拟三个售票窗口同时出售100张票 运用synchronized()方法（线程同步） 1.创建两个类 一个负责主线程 另一个负责子线程 2.第二个Base类 继承Runnable接口 3.实例化第二个Base类 4.用Thread new 出子线程 将第二个类的实例化放进子线程中 public class ThreadSafe ...
Java多线程模拟电影售票过程
08-25
本文主要讲解了Java多线程模拟电影售票过程，通过示例代码详细介绍了多线程的实现和线程同步技术。文章分为两个部分，分别是Test.java和tickets.java，下面对这两个部分进行详细解释。 Test.java Test.java是主...
Java多线程Runable售票系统实现过程解析
08-19
Java多线程Runable售票系统实现过程解析 本文主要介绍了Java多线程Runable售票系统实现过程解析，通过示例代码进行了非常详细的介绍，对大家的学习或者工作具有一定的参考学习价值。 Java多线程 Java多线程是Java...
java多线程之火车售票系统模拟实例
08-30
Java多线程之火车售票系统模拟实例 本文将从Java多线程之火车售票系统模拟实例中提取相关知识点，以便读者更好地理解Java多线程编程的基本概念和应用。 1. 多线程编程 Java多线程编程是指在一个Java程序中同时...
java多线程仿火车票售票
12-24
java课程学习多线程中模仿火车站多窗口同时售票的场景，适合初学者学习
java实现多线程卖票功能
08-25
* 本文中的示例程序是 Java多线程卖票功能的经典案例，旨在帮助读者了解Java中多线程编程的基础知识。 * 在实际应用中，需要根据具体情况选择合适的同步机制来保护共享资源。 * 在编写多线程程序时，需要注意线程...
Java多线程之火车售票系统
08-25
Java多线程之火车售票系统是Java多线程编程中的一种实践应用，通过实现Runnable接口或继承Thread类来创建多线程，实现火车售票系统的并发访问和资源共享。 多线程编程概述 在Java中，多线程编程是指在一个程序中...
基于java的网上购物系统设计与实现
biyesheji1000的专栏
08-12 2734
基于Java的网上购物系统设计与实现的系统性能评估是对系统在特定工作负载下的响应速度和资源利用率进行评估和分析，旨在验证系统是否能够满足用户在实际使用中的性能需求。1、并发性能评估：并发性能是指系统在多用户同时访问的情况下的表现。在这个评估中，我们通过模拟多个用户同时进行登录、浏览商品、下订单等操作，评估系统的并发性能。测试结果显示，系统能够正确处理并发请求，同时保持较好的响应速度。通过增加并发用户数，我们观察到系统能够处理较大的并发访问，并发处理能力和性能表现良好。
多线程-多窗口售票
心比长相好，懂比爱重要
10-30 1669
设计思路 首先要创建两个类，一个窗口类和一个测试类。我是用的是实现Runnable接口的方式来完成的
第十七节 多线程（二）购票经典案例+单例设计模式
云深不知处
08-02 3097
池化技术的思想”主要是为了减少每次获取资源的消耗，提高对资源的利用率。其目的是限制和管理资源，如：使用线程池可以进行统一的分配，调优和监控。降低资源消耗。提高相应速度。提高线程的可管理性。...
一文读懂JAVA多线程基础 包含售票问题详解 内容参考b站韩顺平老师
weixin_51712663的博客
05-03 1262
一文读懂JAVA多线程基础 包含售票问题详解 内容参考b站韩顺平老师
java多线程卖电影票的三种实现方式
最新发布
weixin_43860634的博客
10-09 721
java多线程卖电影票的三种实现方式
Java GUI 实现登录界面
qq_43573663的博客
07-19 7501
具体效果图： 详细代码： package java_gui; import java.awt.Color; import java.awt.Container; import java.awt.Cursor; import java.awt.Font; import java.awt.Image; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.ImageIcon;
java多线程售票窗口
06-02
好的，我可以为您介绍一下 Java 实现多线程售票窗口的方法。 在 Java 中，可以使用 Thread 类来创建一个新的线程。在售票窗口场景中，可以创建多个线程来模拟多个售票窗口同时售票的情况。 首先，需要定义一个 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值