黑马程序员java学习笔记，多线程

多线程
线程时进程中一个独立的控制单元，线程在控制着进程的执行。
一个进程至少有一个线程
JVM启动的时候会有一个进程java.exe
该进程中至少一个线程负责java程序的执行
而且这个线程运行的代码存在于main方法中，为主线程

class ThreadDemo extends Thread {
 public void run(){
  
 }
}
继承一个Thread类：1.定义类继承Thread类2.复写run方法3.调用start()方法
ThreadDemo d=new ThreadDemo();
d.start();//开启线程并执行该线程的run方法
每次运行结果都不是一样的，因为多个线程都获取cpu的执行权，互相抢夺cpu资源。
Thread类用于描述线程，该类定义了一个功能，用于存储线程要运行的代码，该代码就是run方法

wait(),notify(),sleep(time),stop()
Thread.currentThread().getName();当前线程

/*
卖票程序，多个窗口都能卖票
**/
class TicketSell extends Thread{
 private static int tick=100;//使用静态
 public void run(){
  while(true){
  if(tick>0){
   System.out.println(Thread.currentThread().getName()+"sale"+tick--);
  }
  }
 }
}
class TicketDemo{
 public static void main(String[] args){
  TicketSell t1=new TicketSell();
  TicketSell t2=new TicketSell();
  TicketSell t3=new TicketSell();
  TicketSell t4=new TicketSell();
  t1.start();
  t2.start();
  t3.start();
  t4.start();
 }
}

---------------------------------------------------------
1.定义实现Runnable接口
2.覆盖run方法
3.通过Thread类建立线程对象
4.将Runnable接口的子类作为对象传给Thread类的构造函数
5.调用Thread类的start方法开启线程并调用Runnable接口

class TicketSell implements Runnable{//extends Thread{
 private static int tick=100;//使用静态
 Object obj=new Object();
 public void run(){
  while(true)
  {
   Synchronized(obj){
  if(tick>0){
   System.out.println(Thread.currentThread().getName()+"sale"+tick--);
  }
  }
  }
 }
}
class TicketDemo{
 public void main(String[] args){
  TicketSell s=new TicketSell();
  Thread t=new Thread(s);
  t.start();
 }
}
多线程的安全问题
   当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，另一个线程参与进来执行
导致共享数据的错误。
   同步代码块
    synchronized(对象){
  需要被同步的代码；
 }
同步函数,sychronized修饰符修饰函数 就可以了
同步函数使用的锁匙this
静态同步函数使用的锁不是this，因为静态方法中不可以定义this
静态进内存是，内存中没有本类对象，但是一定有类对应的字节码文件对象
类名.class 该对象的类型是class
单例设计模式，懒汉式
1.   class Single{
  private Single(){}
  public static Single s=null;
  public static synchronized Single getInstance(){
   if (s==null)
    s=new Single();
  } 
 }
2.     class Single{
  private Single(){}
  public static Single s=null;
  public static  Single getInstance(){
     synchronized(Single.class){
     if (s==null)
    s=new Single();
    }
  } 
 }
3.更高效的方法
              class Single{
  private Single(){}
  public static Single s=null;
  public static  Single getInstance(){
   if(s==null){
   synchronized(Single.class){
     if (s==null)
    s=new Single();
    }
   }  
  } 
 }
死锁：同步中嵌套同步，但是锁却不同

进程间的通信：多个线程在操作同一个资源，但是操作的动作不同
 
等待唤醒机制
notifyAll();wait();notify();必须都要使用在同步中
用synchronized中的对象来标记