java之路，线程

单线程和多线程：
程序是计算机指令的集合，它以文件的形式存储在磁盘上。
进程：是一个程序在其自身的地址空间中的一次执行活动。进程是资源申请、调度和独立运行的单位，因此，它使用系统中的运行资源；而程序不能申请系统资源，不能被系统调度，也不能作为独立运行的单位，因此，它不占用系统的运行资源。
线程：是进程中的一个单一的连续控制流程。一个进程可以拥有多个线程。线程又称为轻量级进程，它和进程一样拥有独立的执行控制，由操作系统负责调度，区别在于线程没有独立的存储空间，而是和所属进程中的其它线程共享一个存储空间，这使得线程间的通信远较进程简单。
实现新的线程：从Thread类继承,覆盖run方法；实现runable接口
当所有的线程都在后台运行的时候，jvm就会退出。
在java中线程通常运行在抢占式的，不需要时间片分配。java支持不同优先级线程的抢占，但其本身不实现同优先级抢占，如果java所在的操作系统支持同优先级抢占，那么java也会支持

线程的优先级：MAX_PRIORITY(10)    MIN_PRIORITY(1)      NORM_PRIORITY(5)
class ThreadTest
{
 public static void main(String[] args)
 {
  MyThread mth = new MyThread();
 // mth.setDaemon(true);        //设置为后台线程，而且必须在start（）方法之前设置
 // mth.start();           //启动线程
 // mth.setPriority(Thread.MAX_PRIORITY);  //设置优先级,优先级可以随时设置
  new Thread(mth).start();
  while(true)
  {
   //curentThread()获取当前线程的应用，getName()获取名字
   System.out.println("thread name = " + Thread.currentThread().getName());//获取当前线程的名字
  }
 }
}
//创建新线程：定义一个子类继承Thread，覆盖run方法
class MyThread extends Thread
{
 public void run()     //覆盖run方法
 {
  while(true)
  {
   System.out.println(getName());
   yield();        //暂停当前线程，让其它线程执行
  }
 }
}
//创建新线程，实现Runable接口
class MyThread implements Runable
{
 public void run()     //覆盖run方法
 {
  while(true)
  {
   System.out.println(Thread.curretThread().getName());
  // yield();        //暂停当前线程，让其它线程执行
  }
 }
}
同步，同时访问一个变量的时候需要加锁，以防止变量访问不统一
同步的两种方式：同步块和同步方法
每一个对象都有一个监视器，或者叫做锁。
同步方法利用的是this所代表的对象的锁。
每个class也有一个锁，是这个class所对应的Class对象的锁。多个方法访问静态变量，使用Class对象的监视器

多线程模拟火车票售票系统，同时访问变量ticket，需要加锁
class TicketSystem
{
 public static void main(String[] args)
 {
  SellThread st = new SellThread();
  
  new Thread(st).start();
  new Thread(st).start();
  new Thread(st).start();
  new Thread(st).start();
 }
}

class SellThread implements Runnable
{
 int ticket = 100;
 Object obj = new Object();
 public void run()
 {
  while(true)
  {/*
   synchronized(obj)    //同步块，给obj对象加锁。
   {
    if(ticket > 0)
    {
     try
     {
      Thread.sleep(10);
     }
     catch(Exception e)
     {
      e.printStackTrace();
     }
     System.out.println(Thread.currentThread().getName() + "sell ticket:" + ticket);
     // 多个线程同时访问ticket，需要加锁
     ticket--;
    }
   }*/
   
   sell();
  }  
 }
 
 public synchronized void sell()     //同步方法，给this监视器加锁
 {
  if(ticket > 0)
  {
   try
   {
    Thread.sleep(10);
   }
   catch(Exception e)
   {
    e.printStackTrace();
   }
   System.out.println(Thread.currentThread().getName() + "sell ticket:" + ticket);
   ticket--;
  } 
 }
}
每一个对象除了有一个锁之外，还有一个等待队列（wait set），当一个对象刚创建的时候，它的对待队列是空的。
我们应该在当前线程锁住对象的锁后，去调用该对象的wait方法。
当调用对象的notify方法时，将从该对象的等待队列中删除一个任意选择的线程，这个线程将再次成为可运行的线程。
当调用对象的notifyAll方法时，将从该对象的等待队列中删除所有等待的线程，这些线程将成为可运行的线程。
wait和notify主要用于producer-consumer这种关系中,wait方法和notify方法只能出现在同步中

//模拟情报站的系统
class TestWait
{
 public static void main(String[] args)
 {
  Info info = new Info();
  Producer p = new Producer(info);
  Consumer c = new Consumer(info);
  p.start();
  c.start();
 }
}
//生产者产生情报
class Producer extends Thread
{
 Info info = new Info();
 Producer(Info info)
 {
  this.info = info; 
 }
 public void run()
 {
  for(int i=0; i<10; i++)
  {
   info.setId(i);
   System.out.println("setId = " + i);
  }
 }
}
//收获着接收情报
class Consumer extends Thread
{
 Info info = new Info();
 Consumer(Info info)
 {
  this.info = info;
 }
 public void run()
 {
  for(int i=0; i<10; i++)
  {
  // getId();
   System.out.println("getId() = " + info.getId());
  }
 }
}
//情报类
class Info
{
 int id;
 boolean f = false;
 public synchronized int getId()
 {
  if(!f)
  { 
   try
   {
    wait(); //没有情报的时候，无法获取，只能等待，wait会产生异常
   }
   catch(Exception e)
   {
    e.printStackTrace();
   }
  // return id;
  }
  f = false;      //情报取走，f被修改为无情报
  notify();       //通知生产者可以放情报
   
  return id;
 }
 public synchronized void setId(int id)
 {
  if(!f)       
  {
   this.id = id;       //没有情报，就可以放入情报
   f = true;           //f修改为有情报
   notify();           //通知收获者取走情报
  }
  try
  {
   wait();       //如果已经有情报，那么就必须等待收获着取走情报
  }
  catch(Exception e)
  {
   e.printStackTrace();
  } 
 }
}