Java学习记录之多线程

并发与并行
并发：指两个或多个事件在同一个时间段内发生
并行：指两个或多个事件在同一时刻发生(同时发生)
在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单CPU系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行的。
而在多个CPU系统中，则这些可以并发执行的程序便可以分配到多个处理器上实现多任务并行执行，即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行。目前电脑市场上说的多核CPU，便是多核处理器，核越多，并行处理的程序就越多，能大大的提高电脑运行都得效率

线程与进程
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行，是系统运行程序的基本单位。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程

线程调度：
1.分时调度
所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间
2.抢占式调度
优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式。

创建线程类一
Java使用java…lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。
Java中通过继承Thread类来创建并启动多线程的步骤：
1.定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务，因此把run()方法称为线程执行体
2.创建Thread子类的实例，即创建了线程对象
3.调用线程对象的start()方法来启动该线程

//自定义线程类
public class MyThread extends Thread{
   //定义指定线程名称的构造方法
   public MyThread(String name){
     //调用父类String参数的构造方法，指定线程的名称
     super(name);//下面会将关于Thread的方法
   }
   //重写run()方法，完成该线程执行的逻辑
   @Override
   public void run(){
     for(int i=0;i<10;i++){
          System.out.println(getName()+":z正在执行！"+i);//getName方法是Thread中的方法，获取线程的名称
     }
   }
}

//测试类
public class Demo01{
   public static void main(String[] args){
      //创建自定义线程对象
      MyThread mt = new MyThread("新的线程！")；
      //开启新线程
      mt.start();
      for(int i=0;i<10;i++){
          System.out.println("main正在执行！"+i);//执行结果是main函数中的打印和线程中的打印随机进行
   }
}

分析：程序启动运行main时候，java虚拟机启动了一个进程，主线程main在main()调用时候时候被创建。随着调用mt的对象的start方法，会通知JVM要开启新的栈空间留给线程使用，这样另外一个线程也启动了。

Thread类
java.lang.Thread类中的一些方法：
构造方法;
1.public Thread() :分配一个新的线程对象
2.public Thread(String name) :分配一个指定名字的新的线程对象
3.public Thread(Runnable target) :分配一个带有指定目标的新的线程对象
4.public Thread(Runnable target,String name) :分配一个带有指定目标的新的线程对象并指定名字

常用方法：
1.public String getName() :获取当前线程名称
2.public void start() :导致此线程开始执行；java虚拟机调用此线程的run方法
3.public void run() :此线程要执行的任务在此处定义代码
4.public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停(暂时停止执行)
5.public static Thread currentThread() :返回对当前正在执行的线程对象的引用
创建线程的两种方式：一是继承Thread类方式，一种是实现Runnable接口方式

创建线程类二
通过实现Runnable接口来创建线程。采用java.lang.Runnable是非常常见的一种，只需要重写run方法即可
步骤：
1.定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体
2.创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象
3.调用线程对象的start()方法来启动线程

//实现类
public class MyRunnable implements Runnable{
  @Override
 public void run(){
    for(int i=0;i<20;i++){
       System.out.println(Thread.currentThread().getName()+" "+i);
       /*
          此实现类并不是实际的线程类，所以无法直接通过getName()方法获取线程的名称
          只有当此实现类的对象作为Thread的target时，Thread会创建出来新的新的线程，所以只能
          currentThread()方法来获取当前正在执行的线程，然后再getName()获取线程的名称
       */
    }
 }
}

//测试类
public class Demo{
   public static void main(String[] args){
       //创建自定义类对象  线程任务对象
       MyRunnable mr = new MyRunnable();
       //创建线程对象
       Thread t =new Thread(mr,"小强");
       t.start();
       for(int i=0;i<20;i++){
           System.out.println("旺财"+i);
       }
   }
}

tips:
1.实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管时继承Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API 来控制线程的
2.Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅作为线程执行体，而实际的线程对象依然是Thread实例，只有该Thread线程负责执行其target的run()方法

Thread和Runnable的区别
如果一个类继承Thread，则不适合资源共享。但是如果实现了Runnable接口的话，则很容易实现资源共享
扩充：在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实就是在操作系统中启动了一个进程

匿名内部类方式实现线程的创建
使用匿名内部类的方式实现Runnable接口，重写Runnbale接口中的run方法

public class NoNameInnerClassThread{
   public static void main(String[] args){
   /*
       匿名内部类方式：
       new Runnable(){
          public void run(){
             for(int i=0;i<20;i++){
                System.out.println("旺财"+i);
             }
          }
       };//这是一个整体  相当于new Runnable()
    */
    //内部类方式
    Runnable r = new Runnable(){
       public void run(){
          for(int i=0;i<20;i++){
                System.out.println("旺财"+i);
       }
    };
    new Thread(r),start();
    for(int i=0;i<20;i++){
                System.out.println("小强"+i);
   }
}

线程安全
当我们使用多个线程访问同一个资源的时候，且多个线程中对资源有写的操作，就容易出现线程安问题。
要解决上述多线程并发访问一个资源的安全性问题，java中提供了同步机制(synchronized)来解决。
下面通过三个窗口一起售卖数目总共为100张的电影票的案例来分析:
简述:窗口1线程进入操作的时候，窗口2和窗口3线程只能在外等待，窗口1操作结束，窗口1、窗口2、窗口3才有机会进入代码去执行。也就是说在某个线程修改共享资源的时候，其它线程不能修改资源，等待修改完毕之后，才能去抢夺CPU资源，完成对应的操作，保证了数据的同步性，解决了线程不安去的现象

为了实现上述的设想，java引入了线程同步机制，下面介绍三种方式完成同步操作：
1.同步代码块
2.同步方法
3.锁机制

一、同步代码块
同步代码块：synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
格式：
synchronized(同步锁){
需要同步操作的代码
}
同步锁：对象的同步锁只是一个概念，可以想象为在对象上标记了一个锁
1.锁对象可以是任意类型
2.多个线程对象要使用同一把锁
注意：在任何时候，最多允许一个线程拥有同步锁，谁拿到锁就进入代码块，其它的线程只能在外等着(BLOCKED)
使用同步代码块解决代码：

public class Ticket implements Runnable{
   //全局变量  共享资源
   private int ticket =100;
   Object lock = new Object();//创建锁对象
   //执行卖票操作
   @Override
   public void run(){
     //每个窗口卖票的操作
     //while循环 窗口永远开启
     while(true){
       synchronized(lock){
          if(ticket>0){//有票 可以卖
            出票操作
            //使用sleep模拟一下出票时间
            try{
               Thread.sleep(50);
            }catch(InterruptedException e){
                  e.printStackTrace();
            }
            //获取当前线程对象的名字
            String name = Thread.currentThread().getName();
            System.out.println(name+"正在卖："+ticket--);
           }
       }
     }
   }
}

二、同步方法
同步方法：使用synchronized修饰的方法，就叫做同步方法，保证A线程执行该方法的时候，其它线程只能在方法外等着
格式：
修饰符 synchronized 返回值 方法名(参数){
可能会产生线程安全问题的代码
}

同步锁是谁？
1.对于非static方法，同步锁就是Runnable实现类创建的对象，也就是this,谁调用同步方法就是谁
2.对于static方法，我们使用当前方法所在类的字节码对象(类名.class)

public class Ticket implements Runnable{
   private int ticket=100;
   @Override
   public void run(){
      while(true){
         sellTicket();
      }
   }
   /*
     锁对象 是谁调用这个方法 就是谁
     隐含 锁对象 就是 this
   */
   public synchronized void sellTicket(){
       if(ticket>0){
          try{
            Thread.sleep(100);
          }catch(InterruptedException e){
               e.printStackTrace();
          }
          String name = Thread.currentThread().getName();
          System.out.println(name+"正在卖："+ticket--);
       }
   }
}

三、Lock锁
java.util.concurrent.locks.Lock接口提供了比synchronized代码块和synchronized方法更广泛的锁定操作，同步代码块/同步方法具有的功能Lock都有，除此之外更强大，更体现面向对象。
Lock锁也称为同步锁，加锁与释放锁方法化了，如下：
public void lock() :加同步锁
public void unlock() ：释放同步锁

使用步骤：
1.在成员位置创建一个ReentrantLock对象
2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
3.在可能出现安全问题的代码后调用Lock接口中的方法unlock释放锁

java.util.concurrent.locks.ReentrantLock implements Lock接口

public class Ticket implements Runnable{
   private int ticket = 100;
   Lock lock = new ReentrantLock();
   @Override 
   public void run(){
      while(true){
        lock.lock();
        if(ticket>0){
          try{
             Thread.sleep(100);
          }catch(InterruptedException e){
              e.printStackTrace();
          }
          String name = Thread.currentThread().getName();
          System.out.println(name+"正在卖："+ticket--);
        }
        lock.unlock();
      }
   }
}

线程状态
当线程被创建并启动后，它既不是一启动就进入执行状态，也不是一直处于执行执行状态。在线程的生命周期中，有多种状态，下面通过一张图来描述一下线程的生命周期:

Object 类中的方法：
void wait() :在其它线程调用此对象的notify()方法或者notifyAll()方法前，让当前线程一致处于等待状态
void notify() :唤醒在此对象监视器上等待的单个线程，会继续执行wait()方法后的代码

public class WaitingTest{
   public static Object obj=new Object();//全局变量
   public static void main(String[] args){
     //演示waiting无线等待状态
     new Tread(new Runnable(){
          @Override
          public void run(){
            while(true){
               synchronized(obj){
                   try{
                        obj.wait();//无线等待 等待被notify()唤醒
                        //obj.wait(100);//计时等待
                   }catch(InterruptedException e){
                         e.printStackTrance();
                   }
                   System.out.println(Thread.currentThread().getName()+"从waiting状态醒来，获取到锁对象，继续执行了")
               }
            }
          }
     }).start();
     new Thread(new Runnable{
        @Override
        public void run(){
           try{
                Thread.sleep(3000);
           }catch(InterruptException e){
                e.printStackTrace();
           }
           synchronized(obj){
               System.out.println(Thread.currentThread().getName()+"获取到锁对象，调用notify方法，释放锁对象")；
               obj.notify();
           }                
        }
     }).start();
   }
}