class ThreadDemo
{
    public static void main(String [] args)
    {
        Thread tt = new TestThread();
        //tt.setDaemon(true);把线程tt置为后台线程
        tt.start();//这个方法会自动去调用tt的run（）
        int index = 0;
        while(true)
        {
             if(index++ == 100)//执行100次后合并线程
                      try{tt.join(10000);//把tt线程合并到主线程10秒,如果这里是没有参数，那么就永远执行run这                                          //个线程，因为这个线程是个死循环，下面的语句就执行不到了，哈哈}                      catch(Exception e){}
             System.out.println("main()"+Thread.currentThread().gerName()//得到当前执行线程的名字);
        }
    }
}

class TestThread extends Thread
{
   public void run()
   {
      while(true)
      {
             System.out.println("run()"+Thread.currentThread().gerName()//得到当前执行线程的名字);

      }
   }
}

以上说了如何用继承Thread类来创建线程，还有一种方法是类来实现Runnable接口来创建线程
class TestThread extends Thread 这个就要改成 class TestThread implements Runnable
而main中的Thread tt = new TestThread(); 就要改成 Thread tt = new Thread(new TestThread());这里接受的类型是Runnable型的

那么就出现了一个问题，既然两种方法都可以创建线程，那么有什么区别呢？我们来看一个铁路模拟售票系统：
有100张票，我们启动4个线程来卖他们：
class ThreadDemo
{
    public static void main(String [] args)
    {
      /* 如果用这种写法，你会发现实际是启动了4个线程，然后4个线程都有各自的100张票，各买各的，所以这样是错的。
       new TestThread();
       new TestThread();
       new TestThread();
       new TestThread(); */

      /*如果是这种写法，从输出结果中我们发现无论start了多少次，实际还是一个线程，所以这样也是错的。
       TestThread tt = new TestThread();
        tt.start();
        tt.start();
        tt.start();
        tt.start();
      */
      
    }
}

class TestThread extends Thread
{
   int tickets = 100;
   public void run()
   {
      while(true)
      {
             if(tickets>0)
             System.out.println(Thread.currentThread().gerName()+"is saling ticket "+tickets--);

      }
   }
}
这种情况下我们就使用runnable了。请看：
class ThreadDemo
{
    public static void main(String [] args)
    {
        TestThread tt = new TestThread();
        new Thread(tt).start();//四个线程调用同一个线程对象
        new Thread(tt).start();
        new Thread(tt).start();
        new Thread(tt).start();
      
    }
}

class TestThread implements Runnable
{
   int tickets = 100;
   public void run()
   {
      while(true)
      {
             if(tickets>0)
             System.out.println(Thread.currentThread().gerName()+"is saling ticket "+tickets--);

      }
   }
}

总结：使用runnable接口创建多线程比继承thread要灵活。他适合多个相同的程序代码的线程去处理同一资源的情况。

多线程的应用：
1.网络聊天工具开发
  一个线程负责发消息，一个负责收消息。两者互不干扰，如果是单线程，那么就可能前面在等待，而后面就接收不了消息。
2.大量数据库记录的复制。
  如果一个复制要花3天时间，那么当你中途觉得没有必要，要停止的时候，你发现你不能让他停下来。而多线程的情况，一个
  现成负责拷贝，是个无限循环
  while(bStop)
  {get data
   copy data}
  另一个现成监督是否有键盘按下，也就是把原本为true的变量bstop置为false。   bStop = false;当另一线程监视到变量  变化时会停止程序
3.www服务器为每一个来访者创建一个线程

线程安全问题：
我们在上面做的铁路模拟兽票系统有个问题：线程安全问题！
假如当tickets==5的时，系统正好正好要执行tickets--，而还美意执行这个的时候，cpu被切换到另一个线程。那么tickets仍然是5，所以很坑5这张票打印了2次，另一种情况：当票为1的时候系统刚好要打印出1，而这个时候cpu马上切换到了其他线程，它发现票还是1，所以通过了判断大于0，所以打印出了票1。而这个时候票--为0，cpu切换到了刚才的线程，由于刚才的线程在执行打印，所以把票0给打印出来，这些都造成了线程的安全问题

所以我们要把if语句块作为一个原子，放到synchronized()里面。synchronized()里面必须有参数，比如
String str = new String("");
然后把if语句块放到synchronized(str){ if... }里面  这样就实现了同步，避免了线程的不安全。
另外，我们如果希望一个方法是线程安全的，那么我们可以直接在方法名前写上synchronized关键字，比如：
public synchronized void sale(){......} //实际上这种情况下synchronized使用的同步对象是this
注意：str的定义必须放到run方法之外，这个对象应该是全局的，这样才能作为锁旗标！（系统会自动对这个对象进行标识）

线程执行的内部机制：
new Thread(tt).start();
执行start并没有马上去执行线程的run方法，而是再向下继续执行一会，因为cpu还没有这么快就切换到线程上，要想让他马上切换，可以在start后写上：try(Thread.sleep(1);//哪怕是一秒，他也会切换)catch(Exception e){}

如果把代码块的同步用synchronized(this),那么代码块会和有synchronized的方法同步！

1：31 为止 5

类似下面的代码在多线程调用它的时候也要注意线程安全问题：
public void push(char c)
{
  data[index] = c;
  index++;
}

另外有一场景[线程间通信问题]：生产者不停地产生一组数据，消费者不停地去取数据，数据都在缓存中，
class Producer implements Runnable
{
       Q q;
 public Producer(Q q)
        {
            this.q = q;
        }
       public void run()
       {
             int i = 0;
             while(true)
             {
                 if(i==0)
                 {q.name = "zhangsan";
    try{Thread.sleep(1);}catch(Exception e){}//用sleep来模拟cpu切换的现象
                  q.sex = "male";
                  }
                  else
                 {q.name = "lisi";
                  q.sex = "female";
                  }
     i = (i+1)%2;  //使i在0和1之间切换
                

             }
       }
}
class Customer implements Runnable
{
      Q q;
 public Customer(Q q)
        {
            this.q = q;
        }
       public void run()
       {
            
             while(true)
             {
  System.out.println(q.name);
  System.out.println(":"+q.sex);

             }
       }
}
class Q
{
      String name = "unknow";
      String sex = "unknow";
}

//run class
class ThreadCommunation
{
      public static void main(String [] args)
 {
  Q q = new Q();
  new Thread(new Prodecer(q)).start();
  new Thread(new Customer(q)).start();
 }

}
运行后我们会发现名字和性别并没有对应起来，这是因为线程没有同步的问题，要解决这个问题，只需要在两个类的while里
分别加上synchronized(q){}语句块，因为他们都使用同一个对象q，所以用q作为同步监视器
  上面的代码还不是很完善，因为有当消费者取得同步监视器却发现缓冲区根本没有数据的情况，那怎么办？或者当生产者在

取得同步监视器开始生产数据的时候又取得了同步监视器开始放数据，这样就会把原先的数据覆盖！我们使用了wait和notify

对程序修改如下：
class Producer implements Runnable
{
       Q q;
 public Producer(Q q)
        {
            this.q = q;
        }
       public void run()
       {
             int i = 0;
             while(true)
             {
  synchronized(q)
  {
   if(q.bFull)//如果缓冲区是满的 有数据的 那么生产者线程应该wait等待消费者来取数据
   try{q.wait();}catch(Exception e){}
                 if(i==0)
                 {q.name = "zhangsan";
    try{Thread.sleep(1);}catch(Exception e){}//用sleep来模拟cpu切换的现象
                  q.sex = "male";
                  }
                  else
                 {q.name = "lisi";
                  q.sex = "female";
                  }
    q.bFull = true;
    q.notify();//通知消费者有数据要他来取数据
   }
     i = (i+1)%2;  //使i在0和1之间切换
                
  
             }
       }
}
class Customer implements Runnable
{
      Q q;
 public Customer(Q q)
        {
            this.q = q;
        }
       public void run()
       {
            
             while(true)
             {
  synchronized(q)
  {
  if(!q.bFull)  //缓冲区为空的时候交出同步监视器开始等待
      try{q.wait();}catch(Exception e){}
  System.out.println(q.name);
  System.out.println(":"+q.sex);
     q.bFull = false;  //取走数据后缓冲区为空
  
     q.notify(); //通知生产者线程开始执行，这个notify与Producer中的wait对应

  }
             }
       }
}
class Q
{
      String name = "unknow";
      String sex = "unknow";
      boolean bFull = false;
}

//run class
class ThreadCommunation
{
      public static void main(String [] args)
 {
  Q q = new Q();
  new Thread(new Prodecer(q)).start();
  new Thread(new Customer(q)).start();
 }

}

注意：wait和notify方法必须是synchronized的监视器对象的方法，既如果有
synchronized(q),那么就应该q.wait();q.notify(); 如果不写对象，他会默认是this对象
而有可能导致运行时错误[编译没有错误]

任何对象都有wait,notify,notifyAll方法，
wait：告诉当前线程放弃监视器并进入睡眠状态直到其他线程进入同一监视器并调用notify为止；
notify：唤醒同一对象监视器中调用wait的第一个线程。
       用于类似饭馆有一个空位后通知所有等候就餐的顾客中的第一位可以入座的情况。
notifyAll：唤醒同一对象监视器中调用wait的所有线程。具有最高优先级的线程首先被唤醒并执行。
          用于类似某个不定期的培训班终于招生满额后，通知所有的学员都来上课的情况。

实际上上面的代码有些乱，这是因为程序的结构设计不够合理，应该把数据的放和取放到q类中，然后在
这两个方法名前加上关键字synchronized，类似
public synchronized void put(String name,String sex)
{
  if(bFull)
     try{wait();}catch(Exception e){}
  this.name = name;
   try{Thread.sleep(1);}catch(Exception e){}
  this.sex = sex;
  bFull = true;
  notify();
}
我们给别人提供的类是线程安全的，类似上面的代码。别人在使用这个类的时候就不需要考虑线程安全问题，反之，就需要在

外面处理线程安全问题

控制线程的生命周期：
class ThreadLife
{
 public static void main(String [] args)
 {
  ThreadTest tt = new ThreadTest();
  new Thread(tt).start();
  for(int i=0;i<100;i++)
  {
   if(i==50)
    tt.stopMe();
   System.out.println("main() is runing");
  }
 }
}

class ThreadTest implements Runnable
{
 private boolean bStop = false;
 public void stopMe()
 {
  bStop = true;
 }
 public void run()
 {
  while(!bStop)
  {
   System.out.println(Thread.currentThread().getName()+"is running");
  }
 }
}

byte b = 3;
b = b - 1;
以上写法错误 因为如果表达式中有int型数字，那么所有的byte ，shot，char的值都将被提升到int；同样，long，float, double也是如此

System.out.println('a'+1);  结果是98

System.out.println(""+'a'+1); 结果是a1

static void drawTech(int x,int y)
{.........}
这个方法可以直接使用而不需要new，比如在main方法中写drawTech(3，5）；

System.out.println("2+5="+getAres(2,5));而不是
System.out.println("2+5="，getAres(2,5));

非法参数的检查用return;直接返回

函数的重载就是在一个类中允许同时存在一个以上的同名函数，只要它们的参数个数或者类型不同即可

小数之间的除 结果会保留小数部分
整数之间的除 结果抛弃小数部分
-------------------------
int x=5,y;
int y=x/2;//结果是2
--------------------------
int x=5,y;
float f=x/2;//结果是2.0
----------------------------
int x=5,y;
float f=（float）x/2;//结果是2.5  这里发生了表达式数据类型提升
------------------------------------------------------------
int x=3510;x=x*1000/1000;  结果是3000
----------------------------------------
int x=5,y;
y = x%2;//结果是 1
--------------------------------
int x=5,y;
y = -x%2;//结果是 -1
-------------------------------
int x=5,y;
y = x%-2;//结果是 1  表示取摸时 摸数如果是负数 那么负号忽不计算
--------------------------------------
安排房间题目，共有x个学生，每个房间住6人，用一个公式计算他们要住的房间数？
解答：有些人是x/6+1； 显然在x为30的时候就不对了，正解是：（x+5）/6；
这种算法还可以用在查看留言版的分页显示上，x是总留言数，6是每页显示数，结果就是总共多少页面
-----------------------------------------------------------------------------------
假设要让x的值在0到9之间循环变化，写出代码：
int x=0;
while(true)
{
x=(x+1)%10;
}
这个可以用在循环10副图的显示上
-------------------------------------
x = 0x80000000;
y = x>>1;//有符号移位最高位补的是原来的最高位，原来是1就补1，是0补0
System.out.println(Integer.toHexString(y));//将int的y转化为16进制
y = x>>>1;//无符号移无论原来是1还是0都补0
System.out.println(Integer.toHexString(y));//将int的y转化为16进制
-----------------------------------------------------------------------
byte，short,char,int,long都可以移位运算
低于int的操作数先自动转int再移
int型移 最多移31位，因为int最大是32位的 系统将操作数对32取模，得到的结果才是真正的依的位数，a>>33 和a>>1结果是一样的
long型是对64取模
x>>1和x/2结果一样  x<<2和x*4结果一样
-----------------------------------------------------
从键盘读取输入字符的整数值System.in.read();
以下代码为不断读入键盘值，如果是q，那么退出，如果不是q，打印字符
try
{
x=System.in.read();
}
catch(Exception e){}
while(x!='q')
{
    System.out.println((char)x);
    try{
      x=System.in.read();
     }
     catch(Exceotion e){}
}
---------------------------------
声明数组可以：一开始就对数组赋值的叫静态数组
int a[]={1,2,3};
也可以
int []a=new int[]{1,2,3}
如果没有赋值，比如
int []a=new int[]；
打印出来默认的全为0
如果这么定义一个数组int [] y;然后就拿来使用那么是编译通不过的，因为没有初始化，一个数组没有初始化，也没有指向堆中的任何地方，所以也没有默认值
------------------------
int a[4];//声明数组时 不能指定长度，编译将出错。和c不一样
---------------------------------------------------------
int[] x=new int[100];
x= null;
x[1]=3;
这样的代码编译通过，运行出错：空指针错误。 因为x数组指向的是空，所以就没有所谓的第一个元素第二个元素 这点需要注意
同理，当我们调用一个返回的对象的功能时，如果不对这个对象进行检查，而这个对象是空，那么就可能是这种空指针异常
-----------------------------------------------------------------------------------------------------
遍历二维数组
int [][] xx = new int[2][3];
for(int i=0;i<xx.length;i++)
{
      for(int j=0;j<xx[i].length;j++)
          {
            System.out.println(xx[i][j]);
           }

}
-----------------------------------------
int []a=new int[]{9,4,3,8};
Arrays.sort(a);//从小到大排序

2下结束