多线程一

1、进程

是一个执行中的程序，每一个进程执行都有一个执行顺序，该执行顺序是一个执行路径，或者叫一个控制单元。
线程：就是进程中的一个独立的控制单元，线程控制着进程的执行。一个进程中至少有一个线程。
Java jvm启动的时候会有一个进程java.exe，该进程中至少一个线程负责java程序的执行，而且这个线程运行的代码存在于main方法中，该线程称之为主线程。
java jvm启动还会启动一个线程，负责垃圾回收机制的线程。

如何在自定义的代码中,自定义一个线程?线程2种方式：
创建线程的第一种方式:继承Thread类。
步骤：
第一、定义类继承Thread。
第二、覆写Thread类中的run方法。目的是将自定义的代码写入run方法中。
第三、调用线程的start方法，该方法有两个作用，启动线程、调用run方法。
run方法和start方法不同点：
run方法仅仅是对象调用run方法，建立了线程，但是线程并没有运行。
start方法是开启了线程，并执行该线程的run方法。

class Demo extends Thread{
 public void run(){
  for(int x=0;x<50;x++){
   System.out.println("demo run--->"+x);
  }
 }
}
public class ThreadDemo01 {
 public static void main(String[] arg){
  Demo d= new Demo();
  d.start();
  
  for(int x=0;x<50;x++){
   System.out.println("ThreadDemo run===>"+x);
  }
 }
}

创建线程的第二种方式：实现Runnable接口
步骤：
第一、定义类来实现Runnable接口；
第二、覆盖Runnable接口中的run方法，将线程要运行的代码存放在该run方法中。
第三、通过Thread类建立线程对象。
第四、将Runnable接口的子类对象作为实际参数传递给Thread的构造函数。因为自定义的run方法所属的对象是Runnable接口的子类对象，所以要让线程去指定对象的run方法，就必须明确该run方法所属对象。
第五、调用Thread类的start方法开启线程病调用Runnable接口子类的run方法。

class Demo03 implements Runnable{
 private int tick = 100;
 public void run(){
  while(true){
   if(tick>0){
    System.out.println(Thread.currentThread().getName()+"..sale.."+tick--);
   }
  }
 }
}
public class ThreadDemo03 {
 public static void main(String[] args){
  Demo03 d = new Demo03();
  Thread t = new Thread(d);
  t.start();
 }
}

实现方式和继承方式区别：
一般用实现方式，因为实现方式可以避免继承的单继承缺点。
2、线程的运行状态
新建：new一个thread对象或者其子类对象就是创建一个线程。
就绪：新建的对象调用了start方法。
运行：对象的运行方法定义在run中。
冻结：sleep、wait(notify)。
死亡：stop。
3、获取线程对象及名称
线程都有自己默认的名称,Thread-编号，该编号从0开始。Static Thread currentThread()获取当前线程对象。getName()获取线程名称。设置线程名称：setName或者构造函数。
4、多线程的安全问题
多线程出现安全问题的原因：当多条语句在操作同一个线程共享数据的时候，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程就参与进来执行，导致共享数据的错误。
解决多线程安全问题方法：多多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与进来。
java对于多线程的安全问题提供了专业的解决办法：
方法一、同步代码块。
synchronized(对象){
 需要被同步的代码块
}
对象如同锁，持有锁的线程可以在同步代码块中执行，没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。
同步的前提：
第一、必须要有两个或者以上的线程； 第二、必须是多个线程使用同一个锁。
第三、必须保证同步中只能有一个线程在运行。
同步的好处：解决了多线程的安全问题。
同步的弊端：多个线程需要判断锁，比较消耗资源。
方法二、同步函数
函数返回值类型  synchronized 函数名（..）{…}
如何找需要同步的代码
第一、明确哪些代码是多线程运行代码；
第二、明确共享数据；
明确多线程运行代码中哪些语句是操作共享数据的。
5、同步函数的锁是this
同步函数用的是哪一个锁？函数需要被对象调用，那么函数都有一个所属对象引用，就是this,所以同步函数使用的锁是this。

class Ticket implements Runnable{
 private int ticket = 100;
 Object obj = new Object();
 boolean flag = true;
 public void run(){
  if(flag){
   while(true){
    synchronized(this){//同步代码块用的锁自己可以定义一个对象
     if(ticket>0){
      try{Thread.sleep(10);}catch(Exception e){}
      System.out.println(Thread.currentThread().getName()+"..sale.."+ticket--); 
     } 
    }
   }
  }else{
   while(true){
    show(); 
   } 
  }
 }
 public synchronized void show(){//同步函数用的锁为this
   if(ticket>0){
    try{Thread.sleep(10);}catch(Exception e){}
    System.out.println(Thread.currentThread().getName()+"****show****"+ticket--);
   }
 }
}
public class ThreadDemo{
 public static void main(String[] args){
  Ticket t = new Ticket();
  
  Thread t1 = new Thread(t);
  Thread t2 = new Thread(t);
  t1.start();
  try{Thread.sleep(10);}catch(Exception e){}
  t.flag = false;
  t2.start();
   
 } 
}

6、静态同步函数的锁是Class对象
如果同步函数被静态修饰后，使用的锁不再是this，而是Class对象。因为静态方法中不可以定义this，当静态函数进内存时，内存中没有本类对象，但有本类对应的字节码文件对象，就是类名.clss，该对象的类型是Class。

class Ticket implements Runnable{
 private static int ticket = 100;

 boolean flag = true;
 public void run(){
  if(flag){
   while(true){
    synchronized(Ticket.class){//静态的同步方法锁是本类字节码对象
     if(ticket>0){
      try{Thread.sleep(10);}catch(Exception e){}
      System.out.println(Thread.currentThread().getName()+"..sale.."+ticket--); 
     } 
    }
   }
  }else{
   while(true){
    show(); 
   } 
  }
 }
 public static synchronized void show(){//静态同步函数用的锁为Ticket.class字节码对象，即Class对象。
   if(ticket>0){
    try{Thread.sleep(10);}catch(Exception e){}
    System.out.println(Thread.currentThread().getName()+"****show****"+ticket--);
   }
 }
}
public class ThreadDemo{
 public static void main(String[] args){
  Ticket t = new Ticket();
  
  Thread t1 = new Thread(t);
  Thread t2 = new Thread(t);
  t1.start();
  try{Thread.sleep(10);}catch(Exception e){}
  t.flag = false;
  t2.start();
   
 } 
}

7、单例设计模式
单例设计思想：
为了其他程序过多建立该类对象，禁止其他程序建立该类对象---将构造函数私有化。
为了让其他程序能访问到该类对象，在本类中定义一个对象。---》在类中创建一个本类对象。
为了方便其他程序对自定义兑现的访问，可以对外提供一些访问方式---》提供一个方法可以获取该对象。
第一、饿汉式

class SingleDemo{
 private SingleDemo(){}
 private static final SingleDemo s = new SingleDemo();
 public static SingleDemo getInstance(){
  return s;
 }
}

第二、懒汉式

class Single02{
 private Single02(){}
 private static Single02 instance = null;
 public static Single02 getInstance(){
  if(instance==null){//双重否定加同步
   synchronized(Single02.class){//锁为该类所属的字节码文件
    if(instance==null){
     instance = new Single02(); 
    }
   }
  }
  return instance; 
 }
}

8、死锁
a锁调用b锁，b锁调用a锁，循环至死。

总结：

1、实现线程的两种方式：继承Thread类，实现Runnable接口。
2、单例设计模式中饿汉式使用了同步避免bug。