标签：作业
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汽车驶出山洞了~~~~~~~~~
*/标签：作业
原文地址：http://670597669.blog.51cto.com/10018785/1774352
