IT十八掌第八天总结（含作业）

IT十八掌第八天总结

jar
----------------	
	jar cvf xxx.jar -C classes/ .

进程
------------------
	进程之间内存是隔离的。内存不共享。


线程
-------------------
	程序执行过程中，并发执行的代码段。
	线程之间可以共享内存。


	Thread : 线程类
		start()		//通知 Cpu ，可以执行该线程。
		run()		//线程具体执行的代码段。
	Thread t= new Thread();
	t.start();
	Thread.currentThread()   //得到当前的执行线程

	yield() ;                //让线程放弃CPU的抢占权
	sleep(inter mils)	//让当前线程休眠指定的毫秒数。
	join                    //当次进程结束后再运行另一个进程
	sleep （int ms）；      //休眠多长时间后再抢CPU使用权
	start（）；		//启动线程
	run();			//线程的主要方法

	守护线程
	daemon    Thread.setDaemon(true)

	同步代码块
        private static Object lock = new Object() ;  // 新家一个静态对象 lock  lock 是锁旗标
	synchronized(lock){}     //在此范围的进程同步执行 ，保证一段代码在一段时间只能有一个线程在同一执行

	synchronized             //同步函数 使用的锁旗标就是当前对象----this 

	线程安全:	
		synchronized	 
			 增加了同步处理。确保在同一时刻，只有一个线程执行同步代码。
			 同步方法使用的当前对象作为同步对象。
			 静态方法可以加同步处理，使用Class作为同步对象。






举例：


import java.lang.Thread ;                      //导入包
class MyThread  extends Thread{
	public void run(){                     //固定用法 public void
      
		System.out.println("loading.....");
		System.out.println("current:"+Thread.currentThread().getName());		
	}  

}  
class  ThreadDemo {
	public static void main (String [] args){
		 MyThread M= new MyThread();
		 M.start();

		System.out.println("**********************");
		
		new Thread(){                     //匿名内部类
			public void run(){
				System.out.println("loading!!!!!!!!!!!");
			}
		}.start();

			//得到当前的线程
		System.out.println(Thread.currentThread().getName());
	}

}


运行
**********************
loading.....
main
current:Thread-0
loading!!!!!!!!!!!




*******************************************************
为什么thread包还需要导入才能使用
.\Thread.java:2: 错误: 类重复: MyThread
class MyThread  extends Thread{
^
.\Thread.java:9: 错误: 类重复: ThreadDemo
class  ThreadDemo {
^
Thread.java:2: 错误: 无法访问Thread
class MyThread  extends Thread{
                        ^
  错误的源文件: .\Thread.java
    文件不包含类Thread
    请删除该文件或确保该文件位于正确的源路径子目录中。
********************************************************


关于Thread的实例

import java.lang.Thread;          //导入包
class Hero extends Thread{      //新建英雄线程
	private String name;		 //名字
	private int seconds;         //时间

	public Hero (String name, int sec){
		this.name=name;                
		this.seconds=sec;
	}
	//定义run方法      
	public void run(){
		try{                      //可能会报错，使用 try catch
		System.out.println("玩家："+name+"出发啦！");
		//System.out.println(seconds*1000);
		System.out.println("玩家："+name+"到啦！ 花费："+seconds+"秒！");
		}
		catch(Exception e){
			e.printStackTrace(); 
		
		}
	}

}  

class ThreadDemo3{
	public static void main(String [] args) throws Exception{
		//new 英雄
		Hero pl1 = new Hero ("钢铁侠",5);
		Hero pl2 = new Hero ("美队",15);
		Hero pl3 = new Hero ("蜘蛛侠",10);
		Hero pl4 = new Hero ("绿巨人",8);
		//线程开始
		pl1.start();
		pl2.start();
		pl3.start();
		pl4.start();

		//等待执行
        pl1.join();   //join ();  等该线程完成后再执行下一个线程
		pl2.join();
		pl3.join();
		pl4.join();
	 
	   System.out.println("人到齐，开打！！！！");
	
	}



}


运行
/*
玩家：钢铁侠出发啦！
玩家：绿巨人出发啦！
玩家：蜘蛛侠出发啦！
玩家：美队出发啦！
玩家：蜘蛛侠到啦！ 花费：10秒！
玩家：绿巨人到啦！ 花费：8秒！
玩家：钢铁侠到啦！ 花费：5秒！
玩家：美队到啦！ 花费：15秒！
人到齐，开打！！！！
*/



Box案例

//import java.lang.Thread;         
class Box extends Thread{         //box 线程  
	private String boxNo;         //属性
	private int  sec;
	public Box(String boxNo, int sec){   //用构造函数实现
		this.boxNo =boxNo;
		this.sec =sec ;
	
	}

	public void run(){                   //run 方法 
		System.out.println(boxNo + "包厢：开始上菜！！！！");  //首先打印一句话
		try{                             // try  catch  执行
			Thread.sleep(sec*1000);
		}
		catch(Exception e){
		}
		System.out.println(boxNo + "包厢，结账~~~~~~！！");
	}

} 
//创建服务员进程

class Waiter extends Thread {
	private String name;            //属性
	private String idNo;
	private int  sec;
	public Waiter (String name ,String idNo,int sec){
		this.name = name;
		this.idNo = idNo;
		this.sec = sec ;
	}

	public void run(){
		while(true){
			try{
				System.out.println(name+",工号"+idNo+"为您报时，北京时间"+new java.util.Date());
				Thread.sleep(sec*1000);
			}
			catch(Exception e){
			}
		}
	}

}


class ThreadDemo5 {                             //创建Demo类
	public static void main(String [] args){	
		Box bo1 = new Box("001",8) ;            //新建3个box对象和一个  waiter对象  
		Box bo2 = new Box("002",9) ;
		Box bo3 = new Box("003",5) ;

		Waiter w1 =new Waiter("范冰冰","No.0008",1);
		w1.setDaemon(true);    //守护进程 Thread.setDaemon(true);当没有线程在运行或者剩下的全是守护进程时自动结束
		
		bo1.start();                        //开始进程
		bo2.start();
		bo3.start();
		w1.start();
	}
}
	
//运行结果
/*
001包厢：开始上菜！！！！
003包厢：开始上菜！！！！
002包厢：开始上菜！！！！
范冰冰,工号No.0008为您报时，北京时间Mon May 16 19:06:49 CST 2016
范冰冰,工号No.0008为您报时，北京时间Mon May 16 19:06:50 CST 2016
范冰冰,工号No.0008为您报时，北京时间Mon May 16 19:06:51 CST 2016
范冰冰,工号No.0008为您报时，北京时间Mon May 16 19:06:52 CST 2016
范冰冰,工号No.0008为您报时，北京时间Mon May 16 19:06:53 CST 2016
003包厢，结账~~~~~~！！
范冰冰,工号No.0008为您报时，北京时间Mon May 16 19:06:54 CST 2016
范冰冰,工号No.0008为您报时，北京时间Mon May 16 19:06:55 CST 2016
范冰冰,工号No.0008为您报时，北京时间Mon May 16 19:06:56 CST 2016
001包厢，结账~~~~~~！！
范冰冰,工号No.0008为您报时，北京时间Mon May 16 19:06:57 CST 2016
002包厢，结账~~~~~~！！
*/


卖票  （同步线程）

// 卖票线程
class Saler extends Thread{          //新建 线程
	private String name ;            //属性
	private static int tickets = 99 ;  
    
	private static Object lock = new Object() ;  // 新家一个静态对象 lock  lock 是锁旗标
	

	public Saler(String name ){       //构造函数实现
		this.name =name ;
	}

	public void run (){             //run函数
		while(tickets >0){           //while 函数
	
			synchronized(lock) {			//同步线程  只允许获得锁旗标的进入  
			int temp = tickets ;
			tickets = temp -1;

			System.out.println(name+"：票码：00"+temp);
			}
			yield();
		}
	}


}

class ThreadDemo7{                           //新建演示类
	public static void main (String[] args){
		Saler s1 = new Saler("赵本山");      //新建成员
		Saler s2 = new Saler("宋丹丹");

		s1.start();
		s2.start();


	}
	

}


//运行 （局部）
/*
赵本山：票码：0014
宋丹丹：票码：0013
宋丹丹：票码：0012
宋丹丹：票码：0011
宋丹丹：票码：0010
宋丹丹：票码：009
宋丹丹：票码：008
赵本山：票码：007
赵本山：票码：006
赵本山：票码：005
赵本山：票码：004
赵本山：票码：003
赵本山：票码：002
赵本山：票码：001
宋丹丹：票码：000
*/

卖票 改造后

	public void run (){             //run函数
		while(true){               //while 函数  （让函数始终运行）
			//如果满足如下条件，则返回 结束函数
			if (tickets<= 1){   
				return;
			}
			synchronized(lock) {			//同步线程  只允许获得锁旗标的进入  
			int temp = tickets ;
			tickets = temp -1;

			System.out.println(name+"：票码：00"+temp);
			}
			yield();
		}
	}


}

//改造后 不会再出现卖0票 情况 
/*
宋丹丹：票码：0011
赵本山：票码：0010
宋丹丹：票码：009
宋丹丹：票码：008
宋丹丹：票码：007
宋丹丹：票码：006
宋丹丹：票码：005
宋丹丹：票码：004
宋丹丹：票码：003
宋丹丹：票码：002
赵本山：票码：001

*/

/*
1. 5辆汽车过山洞，依次经过山洞。每辆车通过山洞花费10秒，使用多线程实现。
2. 用多线程模拟蜜蜂和熊的关系。
   蜜蜂是生产者，熊是消费者。蜜蜂生产蜂蜜是累加的过程，熊吃蜂蜜是批量（满100吃掉）的过程。
   生产者和消费者之间使用通知方式告知对方。注意不能出现死锁的现象。
*/


class Car extends Thread{                          //新建线程car
	private static int no=5;                       //共有5个
	private String brand;							//品牌
	private int sec ;
 
	public  Object lock = new Object ();			//新建一个静态对象 lock  lock 是锁旗标
	public  Car(int no ,String brand,int sec){      //构造
		this.no =no ;
		this.brand =brand;
		this.sec=sec ;
	}

	public void  run (){							//run函数
		
			synchronized(lock){						//同步
					int temp = no ;
			System.out.println("第"+no+"辆"+brand+"汽车进入山洞了！！！");
			System.out.println("第"+no+"辆"+brand+"汽车驶出山洞了~~~~~~~~~");
		
			try{
				Thread.sleep(100);
			}
			catch(Exception e){}
			no =temp -1;
			
			
			
		}

	}
}

	class ThreadTest1 {
		public static void main(String [] args)throws Exception{  //定义main函数 并抛出异常
			//定义汽车
			Car c1 = new Car(1,"BMW",10);
			Car c2 = new Car(2,"BYD",10);
			Car c3 = new Car(3,"FUTE",10);
			Car c4 = new Car(4,"Benz",10);
			Car c5 = new Car(5,"Landrover",10);
			//题目要求依次通过，所以使用join 让每个函数按照顺序来执行
			c1.start();
			c1.join();
			
			c2.start();
			c2.join();
			c3.start();
			c3.join();
			c4.start();
			c4.join();
			c5.start();
            	        c5.join();
						
		}
		   
	}

//运行后
/**
第5辆BMW汽车进入山洞了！！！
第5辆BMW汽车驶出山洞了~~~~~~~~~
第4辆BYD汽车进入山洞了！！！
第4辆BYD汽车驶出山洞了~~~~~~~~~
第3辆FUTE汽车进入山洞了！！！
第3辆FUTE汽车驶出山洞了~~~~~~~~~
第2辆Benz汽车进入山洞了！！！
第2辆Benz汽车驶出山洞了~~~~~~~~~
第1辆Landrover汽车进入山洞了！！！
第1辆Landrover汽车驶出山洞了~~~~~~~~~
*/