Thread

多线程为我们解决了程序中需要并发执行多个任务的操作，可以通过创建一个线程来负责执行需要执行的任务。创建线程的方式有两种：
1：创建一个类来继承Thread类，在类中重写需要执行对应操作的run方法

class MyThread extends Thread {
   public void run(){
     for(int i=0;i<1000;i++){
       system.out.println(11111);
    }
 }
}
//利用造型创建Thread
public static void main(String[] args){
  Thread t1 = new MyThread();
}
t1.start();

需要注意的是，启动线程需要调用Thread的start方法，而不是重写的run方法，run方法中定义了该线程需要具体做的事情，当start方法调用后，线程纳入线程调度，线程调度会自动分配CPU时间片来执行线程，线程运行时会自动调用run方法。另外，run方法是在start方法调用完毕后执行的，而不是start方法运行过程中执行。
这种创建方法可以匿名类来实现，相对简单

Thread t2 = new Thread(){
  public void run(){
    system.out.println("具体方法");
 }
}

这种线程创建方式由于以下两点不足所以不推荐使用：
a，由于Java是单继承的，所以当当前类继承了Thread类时就不能继承其他父类来实现重用，如果不继承Thread就不能作为单一线程并发，这里出现了继承冲突。
b，由于线程类要执行操作就必须重写run方法，导致线程和执行的任务出现了强耦合关系，该线程只能执行该任务，不利于我们后续对此线程的复用，要知道我们不可能有多少任务就开多少线程，要尽可能的保证效率的同时减少线程数量。
2：单独创建Runnable接口并重写run方法来单独定义任务，并通过Thread实例来实现Runnable接口，实现线程和任务的解耦

Runnable r1 = new Runnable(){
  public void run(){
    system.out.println("任务一");
  }
}
Runnable r2 = new Runnable(){
  public void run(){
    system.out.println("任务二");
  }
}
Thread t = new Thread(r1);
Thread t1 = new Thread(r2);
t.start();
t1.start();

获取当前线程
Java当中所有的程序都是跑在线程上的，Java提供了一个静态方法来获取这个线程
static Thread currentThread()
在哪个方法中运行该方法就会获取运行该方法的线程，main方法也是靠线程运行，其过程是：当程序启动时，操作系统创建一个进程来运行虚拟机，进程运行后会创建一个线程来运行main方法，进程中至少需要一个线程。

Thread t = Thread.currentThread();
System.out.println(t);//Thread[main,5,main]

获取线程相关信息的API

Thread main = Thread.currentThread();
//线程ID
long id = main.getId();
//线程名
String name = main.getName();
//优先级
int priority = main.getPriority();
//是否为守护线程
boolean isDaemon = main.isDaemon();
//是否活着
boolean isAlive = main.isAlive();
//是否被中断
boolean isInterrupted = main.isInterrupted();

线程优先级
线程不能干预线程调度的工作，即线程无法决定时间片分配给哪个线程，也不能决定分配的具体次数，但可以通过更改线程优先级来提高分配到CPU时间片的几率，线程优先级分为10个等级，最低为1，默认5，最高10，理论上优先级越高获取CPU时间片的几率越大。

public static void main(String[] args) {
        new Thread(new Runnable(){
            
            @Override
            public void run() {
                for(int i = 0;i <10; i++){
                    Thread t = Thread.currentThread();
                    t.setPriority(Thread.MAX_PRIORITY);
                    System.out.println("max");
                }
            }
            
        }).start();
        new Thread(new Runnable(){

            @Override
            public void run() {
                for(int i = 0;i <10; i++){
                    Thread t = Thread.currentThread();
                    t.setPriority(Thread.NORM_PRIORITY);
                    System.out.println("normal");
                }
            }
            
        }).start();
        new Thread(new Runnable(){

            @Override
            public void run() {
                for(int i = 0;i <10; i++){
                    Thread t = Thread.currentThread();
                    t.setPriority(Thread.MAX_PRIORITY);
                    System.out.println("min");
                }
            }
            
        }).start();
    }

守护线程
守护线程又叫做后台线程，当一个进程中的所有前台线程都结束时，进程结束前会强制结束后台线程。比如Java中的GC就是一个典型的后台线程，程序运行过程中GC会定时检查堆中是否有垃圾可以清理，当前台线程都结束时GC也会停止工作。

Thread t = new Thread(){
  public void run(){
     System.out.println("这里为后台线程任务");
  }
};
//在启动线程前设置为后台线程
t.setDaemon(true);
t.start();

多线程并发的安全问题

同步锁

当一个程序中有很多线程的时候，会产生多个线程同时访问一个方法的现象，比如两个人同时都想上厕所，就会产生冲突，而程序当中解决这个问题的方法和现实当中一样，就是排队，而排队的先决条件就是给厕所上一个锁，这样即便有人想抢也进不去。
我们利用synchronized关键字来给需要的方法或代码块上锁，例如一个方法被上锁后就不允许多个线程同时执行它，这个方法被称为同步方法

class Bathroom {
  public synchronized void goToBathroom(){
    //假如一个人上厕所耗时5秒
    Thread.sleep(5000);
    System.out.println("厕所有人~");
  }
}
public static void main(String[] args){
  Bathroom bt = new Bathroom();
  Thread person1 = new Thread(){
    public void run(){
      bt.goToBathroom();
    }
  };
  Thread person2 = new Thread(){
    public void run(){
      bt.goToBathroom();
    }
  };
  person1.start();
  person2.start();
}

这两个线程运行起来后线程调度会随机分配时间片给他们，当一个线程在5秒内访问方法的时候该方法就被上了锁，其他线程无法访问，只有访问结束后其他线程才会访问。这样就起到了排队的效果。

有效缩小同步锁的范围可以在保证安全的前提下提高并发效率
比如我们去商场买衣服，先挑选喜欢的衣服然后拿去试衣间试衣服，这两个过程我们没必要都排队，只有试衣服的时候才会排队并且关门上锁，在程序中可以这样表示：

class Shopping{
  Thread t = Thread.currentThread();
  public void buy(){
     System.out.println(t+"正在挑选衣服~");
     Thread.sleep(5000);

     synchronized(this){
     System.out.println(t+"正在试衣服~请排队~");
     Thread.sleep(5000);
  }
  System.out.println(t+"结账离开~");
}

}
public class test{
  public static void main(String[] args){
    Shopping s = new Shopping();
    Thread person1 = new Thread(){
      public void run(){
        s.buy();
      }
    };
   Thread person2 = new Thread(){
      public void run(){
        s.buy();
      }
    };
    person1.start();
    person2.start();
  }
}

这样做可以减少排队时间，提高商场的运作效率，程序中同样，当许多线程同时要访问一个方法而必须排队时我们可以缩小同步范围，只将方法中必须排队执行的代码块进行上锁，而方法中其他代码可以并发执行，减少排队时间。这里需要注意的是在给方法中代码块上锁时要指定一个同步监视器，通常情况下都可用this来指定，即当前对象，要想同步代码块有效果必须保证多线程看到的锁对象是同一个对象。本例中同一个对象指代为同一个商场实例，如果是不同的商场即不同的对象，也就不存在排队或者抢的问题，因为它们根本不搭嘎~

静态方法的同步
当我们给一个静态方法加锁的时候，锁对象就为当前类的类对象，当JVM加载一个类的时候，首先读取该类的class文件，并同时创建一个类对象来保存该类的类信息，一个类有且只有一个类对象，所以静态的同步方法一定有同步效果。

互斥锁

互斥锁是指最多只有一个线程可以持有的锁。当锁对象相同时，如果该对象下有两个方法或者两段代码以上都加了synchronized关键字，代表这两个方法或者代码互斥，互斥意味着当一个线程解锁并执行代码时另外一段加锁的代码其他线程无法解锁，也就无法同时运行，只有当该线程运行完毕归还锁后其他线程才能解锁运行。这种情形通常出现在多线程访问公共资源时，为了避免资源被篡改或丢失，仅允许一个线程进行访问，而在访问期间其他线程无法访问。

class Test{
  public synchronized void methodA(){
    Thread t = Thread.currentThread();
    System.out.println(t+"正在执行A方法~");
    Thread.sleep(5000);
    System.out.println("A方法执行完毕！");
  }
  public synchronized void methodB(){
    Thread t = Thread.currentThread();
    System.out.println(t+"正在执行B方法~");
    Thread.sleep(5000);
    System.out.println("B方法执行完毕！");
  }
}

public class Lock{
  public static void main(String[] args){
    Test test = new Test();
    Thread t1 = new Thread(){
      public void run(){
        test.methodA();
      }
    };
    Thread t2 = new Thread(){
      public void run(){
        test.methodB();
      }
    };
    t1.start();
    t2.start();
  }
}