Java的Thread（笔记）

/*
进程：是一个正在执行中的程序。
	每一个执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。
线程：就是进程中的一个独立的控制单元。
	线程在控制着线程的执行。
每个程序至少有一个线程的运行，其java中，在我们编写运行时有一个main主线程。
创建线程的第一种方式：继承Thread，
	继承后必须实现run()方法，
	以start()方法启动方法
	以sleep()睡眠时间，抛InterruptedException
	以wait()等待状态线程
	以notify()叫醒等待的线程
	以stop()停止线程
	*/
class Demo extends Thread{
	public void run(){
		System.out.println(Thread.currentThread.getName+"demo run");
		//显示正在运行的线程名称，没设置名称默认为Thread-x
	}
}
class ThreadDemo{
	public static void main(String[] args){
		Demo d = new Demo();
		d.star();	
		//当main线程执行到这一步是开启d这个线程，这时就有了面和d两个线程
		//d.run();	//要区分启动线程和调用方法的区别
		for(int x = 0; x< 90;x++){
			System.out.println("main run");
		}
	}
}
在Thread类中run方法是存储线程要运行的代码
/* 简单买票程序,多窗口同时售票 */
class Ticket implements Runnable //extends Thread{
	private int tick = 100；
	//private static int tick = 100;	
	//当new出一个Ticket就有100张票，但静态的生命周期太长。
	boolean fag = true;
	public void run(){
		if(fag){
			while(true){
				synchronized(this){
				//如此锁与下面show的参数对象不同，在相对于不在同一的空间的锁，所以必须传个一致的对象来申明是同一锁
					if(tick>0){	
					System.out.println(this.getName()+"code:"+tick--);
				}
			}
		}
		}else{
			show();
		}
	}
	public synchronized void show(){
	//这时synchronized参数默认是类本身对象，如是静态方法则是此类的字节码对象
		if(tick>0){	
			System.out.println(this.getName()+"sale:"+tick--);
		}
	}
}
public class TicketDemo{
	public static void main(String[] args){
		/*
		Ticket t1 = new Ticket();
		Ticket t2 = new Ticket();
		Ticket t3 = new Ticket();
		Ticket t4 = new Ticket();
		t1.start();
		t2.start();
		t3.start();
		t4.start();
		//当一个线程被启动时再次启动后会报IllegalThreadStateException
		*/
		Thread t1 = new Thread(Ticket);
		Thread t2 = new Thread(Ticket);
		t1.start();
		try{Thread.sleep(20);}catch(Exception e){}
		t.flag=false;
		t2.start();
	}
}
/*
第二种方式：实现Runnable接口，此类以参数形式传给new出来的Thread对象,让Thread去执行指定的run()方法。
线程的实现方式与继承方式的区别：
	java只支持单继承，可实现多接口，实现接口学实现接口所定义好的规则。
线程安全问题：
	当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没执行完，另一个线程参与进来，导致共享数据的错误。
	同步：只有锁的线程可以再同步中执行，没有持有锁的线程即使获得cpu执行权，也不能执行，没有获取所。
同步代码块：
synchronized(对象){} 线程安全，但消耗资源
*/
/* 存储金额 小程序 */
/*
	先查找共享数据
*/
class Bank{
	private int sum;
	Object obj = new Object();
	public synchronized void add(){
		sum = sum + n;
		System.out.println("sum" + sum);
	}
}
class Cus implements Runnable{
	private Bank b = new Bank();
	public void void run(){
		for(int x =0; i<3;x++){
			b.add(100);
		}
	}
}
public class BankDemo{
	public static void main(String[] args){
		Cus c k = new Cus();
		Thread t1 = new Thread(c)j;
		Thread t2 = new Thread(c)j;
		t1.start();
		t2.start();
	}
}
/* 单例模式懒汉模式 */
class Single{
	private static Single s = null;
	private Single(){}
	public static synchronized Single getInstance(){
		if(s==null){
			synchronize(Single.class){
				if(s==null){//当多个线程都运行到这时，就会出现多个对象
					s = new Single();
				}
			}
		}
		return s;
	}
}

public class SingleDemo{
	pubic static void main(String[] args){
		System.out.println("hello world")
	}
}
/* 单例模式饿汉模式，它不要存在多线程的隐患 */
class Single{
	private static final Single s = new Single();
	private Single(){}
	public static Single getInstance(){
		return s;
	}
}
/* 死锁01 */
class Test{
	private boolean flag ;
	Test(boolean flag){
		this.flag = flag;
	}
	public void run(){
		if(flag){
			synchronized(MyLock.locka){//如果当对象t1进入此兑现，拿到了a锁
				System.out.println("if locka");
				synchroized(MyLock.lockb){//当在去拿b锁是已经被t2拿了
					System.out.println("if lockb");
				}

			}
		}else{
			synchronized(MyLock.lockb){//如果当对象t2进入此兑现，拿到了b锁
				System.out.println("else lockb");
				synchroized(MyLock.locka){//与以上一样，都停止到着
					System.out.println("else locka");
				}

			}
		}
	}
}
class MyLock{
	static Object locka = new Object();
	static Object lockb = new Object();
}
public class DeadLockTest{
	public static void main(String[] args){
		Thread t1 = new Thread(new Test(True));
		Thread t2 = new Thread(new Test(false));
		t1.start();
		t2.start();
	}
}
/* 线程间通信 */
/* 多个线程操作同一个资源，但操作不同动作 */
class Res{
	private String name;
	private String sex;
	boolean flag = false;
	public synchronized void set(string name, String sex){
	//为避免但name赋值时切换到另一个线程将此方法设置为同步，当进入了此方法后说明添加了个对象，将进入此方法的线程所同步锁设为等待
	//input进来，flag为false
		if(flag){
			try{this.wait();}catch(Exception e){}
		}
		this.name = name;
		this.sex = sex;
		this.flag = true;
		this.notify();
	}
	public synchronized void out(){
	//当进入了此方法后说明添获取对象，将进入此方法的线程设为等待
	//output执行，flag为false，它与input同时在执行，当input吧锁解开后此方法继续开始
		if(!flag){
			try{this.wait();}catch(Exception e){}
		}
		System.out.println(r.name+" "+r.sex);
		this.flag = false;
		this.notify();
	}
}
class Input implements Runnable{
	private Res r;
	int x=0;
	Input(Res r){
		this.r = r;
	}
	public void run(){
		while(true){
			synchronized(r){
				if(x==0){
					r.set("aa","girl");
				}else{
					r.set("bb","body");
				}
				x = (x+1)%2;
			}
		}
	}
}
class Output implements Runnable{
	Output(Res r){
		this.r = r;
	}
	public void run(){
		while(true){
			r.out();
		}
	}
}
class InputOutputDemo{
	public static void mian(String[] args){
		Res r = new Res();
		new Thread(new Input(r)).start();
		new Thread(new Output(r)).start();
	}
}

/* Lock */
/* 
interrupt中断线程
setDaemon 守护(后台)线程，当前台线程结束，那java虚机退出
join	抢夺执行权，主线程等待，当用此方法的线程结束或主线程苏醒
setPriority(int 0-10) 设置线程优先级
yield 暂时停止正在执行的线程
*/
class Resource{
	privete String name;
	private int count = 1;
	private boolean flag = false;
	private Lock lock = new ReentranLock(); 
	private Condition pro = lock.newCondition();
	private Condition con = lock.newCondition();

	public void setNaem(String name) throws InterruptedExcetion{
		lock.lock();
		try{
			while(flag){
				pro.await();
			}
			this.name = name + "--" + count++;
			System.out.println(Thread.currentThread().getName()+""+this.name);
			flag = true;
			con.signal();
		}finally{
			lock.unlock();
		}
	}
	
	public void getNaem() throws InterruptedExcetion{
		lock.lock();
		try{
			while(flag){
				con.await();
			}
			System.out.println(Thread.currentThread().getName()+""+this.name);
			flag = false;
			pro.signalAll();
		}finally{
			lock.unlock();
		}
	}
}

class Producer implements Runnable{
	privae Resource res;
	Producer(Resource res){
		this.res = res;
	}

	public void run(){
		while(true){
			try{
				res.setName("+商品+")
			}catch(InterruptedExcetion e){}
		}
	}
}
class Consumer implements Runnable{
	privae Resource res;
	Consumer(Resource res){
		this.res = res;
	}

	public void run(){
		while(true){
			try{
				res.getName("+商品+")
			}catch(InterruptedExcetion e){}
		}
	}
}

public ProducerConsumerDemo{
	public static void main(String[] args){
		Resource res = new Resource();

		Producer p1 = new Producer();
		Producer p2 = new Producer();
		Consumer c1 = new Consumer();
		Consumer c2 = new Consumer();
		
		p1.start();
		p2.start();
		c1.start();
		c2.start();
	}
}
//部分属于个人解说，可能有误！