Java线程总结

1.进程：在操作系统上运行的一个应用程序，每一个进程都拥有自己独立的内存空间
  线程：一个应用程序可以有多个子任务，每一个子任务就是一个线程

  并发:当进程中多个线程同时运行时，这种运行方式称为并发。
  
但是在同一时间点cpu只能处理一个线程,宏观上并行，微观上串行
  
  java.exe就是jvm  进程
  每一个进程都有一个主线程，也就是应用程序的入口函数main函数运行时产生的线程，
  在一个进程中各个子线程的执行顺序是不确定，要想执行必须抢占到cpu资源
  这个工作是交给系统提供的虚拟cpu 来做的，在java中就是jvm决定分配cpu给哪个线程执行
  
2.创建线程的两种方法：
  1）继承Thread重写run方法
      public class MyThread extends Thread{
          public void run(){
              执行操作
          } 重写该方法
      }
    MyThread t = new MyThread();//创建一个线程
    t.start();//启动一个线程  
    线程启动后，如果能够抢占到cpu，线程会自动调用线程的run方法。  
   
    Thread类中的run方法：因此如果不重写run方法，线程启动后就什么都不做。
   
   
  2）实现Runnable接口
    public class MyThread implements Runnable {
        public void run(){}
    }
    MyThread mt = new MyThread();
    Thread t = new Thread(mt);//包装一个线程
    t.start();//启动后自动调用mt的run方法

3.run()和start()的区别
    run();线程体方法，自身是一个普通方法，线程启动后会自动调用
          如果直接调用会被当做是普通的方法运行
    start();是启动线程的方法，调用后线程进入就绪状态,
            而不是马上执行，当抢占到cpu后才会去执行run()方法
            这个时候线程进入running状态，每个线程只能运行start启动一次。

4.Thread常用方法：
静态方法：
    currentThread（）；返回但前正在执行的线程
  sleep(long);让当前线程处于阻塞状态，停止指定时间，单位为毫秒
               停止时间结束，本进程转入就绪状态继续执行
    yield（）；中止当前线程，让优先级大于等于自己的线程运行，
            自己进入就绪状态,只是把执行权让出,自己仍然参与cpu的抢占
            如果就绪状态中的线程中优先级没有比自己高，则什么都不做

非静态方法：   
    join（）；中止当前线程，等待指定线程运行结束，然后在执行当前线程
        例如：在线程a中调用b.join();则a进入阻塞，直到b中止

  interrupt();中断线程，线程进入阻塞状态。
  注： 调用中断方法的线程不能处于阻塞状态，
   否则会抛出中断异常
  isInterrupt();判断当前线程是否中断
  t.getName();得到线程的名字
  
注：            
线程的优先级：主线程默认优先级为5，最大为10
  原则上：优先级高就会先抢占到cpu去运行
  java可以设置线程的优先级setPriority();
  但是优先级依赖于操作系统的支持，因此在编程过程中不提倡使用


5.线程的并发：在同一时刻运行多个线程。

    多个线程同时访问同一个数据的时候就产生数据共享问题。
    数据共享问题是说，多个线程同时修该这个共享数据导致结果不确定。
   
    线程不安全的：
        线程对象中有实例类型的属性,就有可能产生共享数据

    处理线程不安全的方法：
        1）将使用到的全局变量改为局部变量（优先考虑）
            在每一次调用方法的时候，方法都会被重新压栈，
            局部变量会被重新创建，因此也不会和其他线程共享
        2）同步：利用 锁机制

6.概念：
    对象锁：
        每一个对象只有一把锁，对象锁在同步代码块结束时候被释放
        对象的锁是唯一的，这样才能保证并发操作的时候利用锁来解决
        数据共享问题。
    锁池：
        每个对象都有一个锁池
        一个线程需要得到对象锁时，如果对象锁不是空闲的，
        正在被使用，那么该线程就会被放到对象的锁池中

7.解决数据共享问题：
        synchronized  同步代码关键字，可以解决共享数据的冲突，
        保证数据的完整性和一致性
   
    1）线程体内用写同步代码块
                synchronized(obj){  要同步执行的块  }
    2）方法上的同步  
        public synchronized void method(){}
        等价于：
            方法体中的代码全部是同步的，同步的对象为当前对象
            synchronized(this)
            
    注：静态方法也可以加同步
        构造方法没有同步,抽象方法没有同步
   
    如果线程要运行同步代码块，必须先得到对象的锁，
    运行同步代码块中的语句时候不受外界的干扰。

8.死锁：
  多线程并发中，每个线程不释放自己拥有的对象锁，却又申请别的线程拥有的资源。
  这个时候就会产生死锁。

  
  调用obj的wait方法释放锁
  notify()/notifyAll();唤醒等待
               
   
9.
    wait() 中止当前线程，释放对象obj的锁，线程进入等待状态。
        等待状态中的线程，重新开始运行需要被唤醒。
    wait（long）；等待指定的时间，如果等待时间结束还没有被唤醒，就自动进入就绪状态。
    notify()随机唤醒等待状态的线程。
   
注：
    wait 和 notify 是联合使用的，必须写在synchronized同步块中
    wait方法是释放对象的锁的，如果没有拥有怎么释放?
    所以必须写在synchronized同步块中（synchronized是用来获得对象锁的）
    notify()方法随机唤醒等待状态的线程，如果没有线程处于等待状态就什么都不做。

    notifyAll()唤醒所有被obj叫停的线程。

唤醒线程3种方法：    notify()  notifyAll()  interrupte()

wait和sleep的区别：
    1）wait是从object继承下来的方法，sleep是Thread中静态的方法
    2）线程调用obj.wait后进入等待池，sleep进入阻塞状态
    3）wait要释放锁，而sleep不释放
    4）wait必须放在同步块中，sleep可以放在任何地方调用，
        sleep时间到后自动回到就绪状态，而wait是需要被唤醒的。
   
10.
线程状态总结：
    1）新建状态（new）：这个时候线程只是处于JVM中，
        只是创建了一个线程对象，并没有真正的运行
    2）就绪状态（Runnable）：调用线程对象的start（）方法后，
        此时线程对象进入runnable状态，等待cup的执行
    3）运行状态（running）：正在运行的线程，执行run方法，cpu此时被他占用
                     当cpu时间片结束，该线程还没有
    4）阻塞状态（blocked）：运行状态中的线程，如果调用了sleep，join
        或者interrupt（中断线程的状态）等方法都会导致线程进入阻塞状态，
        从阻塞状态出来的线程不会马上进入运行状态，而是从新回到runnable就绪状态
    5)死亡状态：run方法执行之后
    6)等待池（等待队列）：    一个线程调用wait方法，线程会自动释放锁，并进入等待队列，
            只有当另外一个线程调用notify或者notifyAll的时候（建议使用notifyAll）
            这样才能将等待队列中的线程全部唤醒，进入就绪状态
        
    7)锁池状态：每个对象都有唯一的锁，以防止做为共享数据的时候发生冲突，影响数据的
            一致性或者完整性。一个线程拥有一个对象的锁后，其他线程要想访问必须在
            锁池中等待，等第一个线程使用完释放后他才能使用并且运行。从锁池出来的线程
            也不是直接运行的，而是进入runnable（就绪）状态