孙鑫Java无难事07

程序 CPU
线程 操作系统 时间片

 

不要去利用高优先级将始终运行的特点来完成某些功能

 

并不需要修改线程类当中除了run()方法之外的其它方法的行为之外 => Runnable

 

Runnable接口的这两个好处，都可以通过内部类来完成
如果MyThread类已经继承了一个类
对实现Runnable接口去实现一个线程的话，如果多个线程要访问同一种资源的话，是很方便的

 

火车票售票系统

 

如果在一个类中，有一个静态的方法，它访问了一个静态的变量，而这个静态的方法又需要在多个线程中被同时访问，那么我们就需要对静态方法的使用进行同步。
同步静态方法 使用的就是 这个方法所在的类所对应的Class对象的监视器

 

http://java.sun.com/docs/books/jls/
Java编程规范(第三版)

 

MultiThread.java

class MultiThread
{
	public static void main(String[] args) //程序的入口函数，也就是main方法所在的线程的入口函数
	{
		MyThread mt=new MyThread();
		/*new Thread(mt).start();
		new Thread(mt).start();
		new Thread(mt).start();
		new Thread(mt).start();*/
		mt.getThread().start();
		mt.getThread().start();
		mt.getThread().start();
		mt.getThread().start();
		//mt.setDaemon(true);
		//mt.setPriority(Thread.MAX_PRIORITY);
		//mt.start();
		int index=0;
		while(true)
		{
			/*if(index++==1000)
			{
				break;
			}*/
			System.out.println("main:"+Thread.currentThread().getName());
		}
	}
}

class MyThread //implements Runnable//extends Thread
{
	int index=0;
	private class InnerThread extends Thread
	{
		public void run()
		{
			while(true)
			{
				System.out.println(Thread.currentThread().getName()+":"+index++);
			}
		}
	}
	Thread getThread()
	{
		return new InnerThread();
	}
	/*public void run() //线程的入口函数
	{
		while(true)
		{
			System.out.println(Thread.currentThread().getName()+":"+index++); //Thread-0 JVM
			//yield();
		}
	}*/
}

 

TicketsSystem.java

class TicketsSystem
{
	public static void main(String[] args)
	{
		SellThread st=new SellThread();
		
		new Thread(st).start();
		try
		{
			Thread.sleep(1);
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
		st.b=true;
		new Thread(st).start();
		//new Thread(st).start();
		//new Thread(st).start();
	}
}

class SellThread implements Runnable
{
	int tickets=100;
	Object obj=new Object();
	boolean b=false;
	public void run()
	{
		if(b==false)
		{
			while(true)
			{
				sell();
			}
		}
		else
		{
			while(true)
			{
				//synchronized(this)	//让同步方法和同步 this对象 进行一个同步
				synchronized(obj)	//线程进来时，首先判断obj这个对象的监视器(锁)是否被加锁
				{
					try
					{
						Thread.sleep(10);
					}
					catch(Exception e)
					{
						e.printStackTrace();
					}
					synchronized(this)
					{
						if(tickets>0)
						{
							System.out.println("obj:"+Thread.currentThread().getName()+
							                   " sell tickets:"+tickets);
							tickets--;
						}
					}
				}
			}
		}
	}
	public synchronized void sell()	//当一个线程进入到这个方法的时候，它需要给这个类中this对象的监视器加上一把锁，
	{
		synchronized(obj)
		{
			if(tickets>0)
			{
				try
				{
					Thread.sleep(10);
				}
				catch(Exception e)
				{
					e.printStackTrace();
				}
				System.out.println("sell():"+Thread.currentThread().getName()+
				                   " sell tickets:"+tickets);
				tickets--;
			}
		}
	}
}

 

Test.java

class Test
{
	public static void main(String[] args)
	{
		Queue q=new Queue();
		Producer p=new Producer(q);
		Consumer c=new Consumer(q);
		p.start();
		c.start();
	}
}

class Producer extends Thread
{
	Queue q;
	Producer(Queue q)
	{
		this.q=q;
	}
	public void run()
	{
		for(int i=0;i<10;i++)
		{
			q.put(i);
			System.out.println("Producer put "+i);
		}
	}
}
class Consumer extends Thread
{
	Queue q;
	Consumer(Queue q)
	{
		this.q=q;
	}
	public void run()
	{
		while(true)
		{
			System.out.println("Consumer get "+q.get());
		}
	}
}
class Queue
{
	int value;
	boolean bFull=false;	//判断队列是否是满的
	public synchronized void put(int i)
	{
		if(!bFull)	//如果队列不是满的，就放置数据
		{
			value=i;
			bFull=true;	//放完数据之后
			notify();	//通知消费者去获取数据
		}
		try
		{
			wait();	//让生产者等待消费者获取数据之后，再通知生产者继续去放置数据
			        //使用的是this对象的等待队列
			        //当调用一个wait方法和notify方法时，它们必须是同一个对象的等待队列
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
	}
	public synchronized int get()
	{
		if(!bFull)
		{
			try
			{
				wait();	//如果队列为空，让消费者继续等待。
				        //消费者等待，当生产者放置了数据之后，它会调用 notify() 方法，于是消费者线程得以继续运行
				        //=消费者线程被从对象的等待队列中删除，变为可运行
			}
			catch(Exception e)
			{
				e.printStackTrace();
			}
		}
		bFull=false;
		notify();	//通知生产者继续放置数据
		return value;
	} 
}