基本线程类

1. 继承Thread类

public class MyThread extends Thread {  
　　public void run() {  
　　 System.out.println("MyThread.run()");  
　　}  
}  
MyThread myThread1 = new MyThread();  
MyThread myThread2 = new MyThread();  
myThread1.start();  
myThread2.start();

Thread类本质上是实现Runnable接口的一个实例，代表一个线程的实例。启动线程的唯一方法是通过Thread类的start()实例方法。start()是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。 **多个线程之间无法共享线程类的实例变量 **

2.实现Runnable接口

public class MyThread extends OtherClass implements Runnable {  
　　public void run() {  
　　 System.out.println("MyThread.run()");  
　　}  
} 
MyThread myThread = new MyThread();  
Thread thread = new Thread(myThread);  
thread.start(); 

3.实现Callable接口通过FutureTask包装器来创建线程

Callable接口提供了一个call()方法可以作为线程执行体，这个方法具有返回值，还可以声明抛出异常

实现Callable接口通过FutureTask包装器来创建Thread线程future模式 并发模式的一种, 可以有二种形式, 无阻赛和阻塞,分别是isDone和get其中future 对象用来存放该线程的返回值以及状态

//Callable接口
public interface Callable<V>   { 
  V call（） throws Exception;  
} 

public class SomeCallable<V> extends OtherClass implements Callable<V> {

    @Override
    public V call() throws Exception {
        // TODO Auto-generated method stub
        return null;
    }
}
Callable<V> oneCallable = new SomeCallable<V>();   
//由Callable<Integer>创建一个FutureTask<Integer>对象：   
FutureTask<V> oneTask = new FutureTask<V>(oneCallable);   
//注释：FutureTask<Integer>是一个包装器，它通过接受Callable<Integer>来创建，
//它同时实现了Future和Runnable接口。 
  //由FutureTask<Integer>创建一个Thread对象：   
Thread oneThread = new Thread(oneTask);   
oneThread.start();   //至此，一个线程就创建完成了

4.使用ExccutorService，Callable，Future实现有返回结果的线程

ExecutorService pool = Executors.newFixedThreadPool(taskSize); 
   for (int i = 0; i < taskSize; i++) {  
    Callable c = new MyCallable();  
    // 执行任务并获取Future对象  
    Future f = pool.submit(c); 
    list.add(f);  
   }  
    // 关闭线程池  
    pool.shutdown();  
    //从Future对象上获取任务的返回值
    f.get()     
   // 获取所有并发任务的运行结果  
//实现Callable接口
class MyCallable implements Callable<Object> {  
public Object call() throws Exception {  
   return null;  
}  

• ExecutoreService提供了submit()方法，传递一个Callable，或Runnable，返回Future。如果Executor后台线程池还没有完成Callable的计算，这调用返回Future对象的get()方法，会阻塞直到计算完成

ExecutorService e = Executors.newFixedThreadPool(taskSize); //新建线程池
 //submit方法有多重参数版本，及支持callable也能够支持runnable接口类型.
Future future = e.submit(new myCallable());
future.isDone() //return true,false 无阻塞
future.get() // return 返回值，阻塞直到该线程运行结束

总结 :Runnable，Callable接口与Thread类的对比

• 采用实现Runnable，Callable接口优缺点：
  1，接口可以多继承，继承了Runnable接口还能继承其他接口
  2，适合多个相同线程来处理同一份资源的情况，
  3，缺点是，编程稍微复杂，访问当前线程必须使用Thread.currentThread()
• 采用继承Thread类优缺点：
  1，编写简单，访问当前线程可直接用this
  2，缺点是，不能再继承其他类
  综上，建议采用实现Runnable接口的方法来创建和启动线程

synchronized关键字

synchronized关键字用于修饰方法和代码块，以实现同步，当多个线程在执行被synchronized修饰的代码，以排队的方式进行处理。当一个线程调用被修饰的代码时，先判断有没有被上锁，如果上锁就说明有其他线程在调用，必须等待其他线程结束调用后才能执行这段代码，synchronized可以在任意对象以及方法上加锁，加锁的这段代码被称为“互斥区”或者“临界区”

synchronized关键字加到static静态方法是给Class类上锁

synchronized关键字加到非static静态方法上是给对象上锁

关于并行,并发和同步的概念

• 并行:
  • 多个CPU实例或者多台机器同时执行一段处理逻辑,是真正的同时.
• 并发
  • 通过CPU调度算法,让用户看上去同时执行,实际上CPU操作层面不是真正的同时,并发往往场景中有公共资源,那么针对这个公用的资源往往产生瓶颈,我们会用TPS或者QPS来反应这个系统的处理能力
• 同步
  • Java中的同步指的是通过人为的控制和调度,保证共享资源的多线程访问成为线程安全,.来确保结果的准确,如上面的

线程安全

• 指在并发的情况下,改代码经过多线程的使用,线程的调度顺序不影响任何结果,这个时候使用多线程,我们只需要关注系统功能的内存,Cpu是不是够用即可,反过来,线程不安全就意味着线程的调度顺序会响应最终结果
  1. 多个线程同时操作一个全局变量是不安全的，使用自旋锁并不是绝对的安全（因为单写多读）。
  2. 在多个线程进行读写操作时，仍然能够保证数据的正确 。使用互斥锁可以实现，但是消耗性能
  3. 所有更新UI的操作都在主线程上执行

线程的状态

• 新建状态:使用new 关键字和Thread类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start()这个线程。

• 就绪状态:当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。

• 阻塞(Blocked) : 对Running状态的线程加同步锁synchronized使其今如(Lock Blocked Pool) 同步锁被释放今如可运行状态,

• 等待(Waiting) :线程可以主动调用obj.wait或者Thread.sleep或者 join 今入,Waiting是等待另一个线程完成某一个操作,如join等待另一个完成执行.

• waiting 和 Blocked状态, Blocked也是一种等待,等待的是monitor 但是waiting等待是notify()方法

每个对象都有的机制

• monitor :Java中 每个对象都有一个监视器,来监视并发代码的重入,在非多线程编码时改监视器不发挥作用,反之如果在``synchronized`范围内,监视器发挥作用.
• wait/notify 必须存在于synchronized块中, 并且这三个关键字针对的是同一个监视器,意味着wait之后,其他线程可以进入同步代码块
• synchronized 单独使用 在多线程环境下，synchronized块中的方法获取了lock实例的monitor，如果实例相同，那么只有一个线程能执行该块内容

优雅地停止线程

• interrupt阻塞中断和非阻塞中断

• interrupt()方法并不会立即执行中断操作，这个方法只会给线程设置一个为true的中断标志。设置之后，则根据线程当前的状态进行不同的后续操作。

• 线程的当前状态处于非阻塞状态，那么仅仅是线程的中断标志被修改为true而已（2）如果线程的当前状态处于阻塞状态，那么在将中断标志设置为true后，如果是 wait、sleep以及join 三个方法引起的阻塞，那么会将线程的中断标志重新设置为false，并抛出一个InterruptedException，这样受阻线程就得以退出阻塞的状态。

  public class TestThread1 {
  
      public static void main(String[] args) {
          MyRunnable1 myRunnable=new MyRunnable1();
          Thread thread=new Thread(myRunnable,"子线程");
          thread.start();
          try{
              //主线程休眠
              Thread.sleep(3000);
              //调用中断，true
             thread.interrupt();
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
      }
  }
  
  class MyRunnable1 implements Runnable{
  
      @Override
      public void run() {
        int i=0;
        while(true){
            System.out.println(Thread.currentThread().getName()+"循环第"+ ++i+"次");
            try{
              //判断线程的中断情况
                  boolean interruptStatus=Thread.currentThread().isInterrupted();
                  System.out.println(Thread.currentThread().getName()+"循环第"+ ++i+"次"+interruptStatus);
                  Thread.sleep(1000);
                  //非阻塞中断 只是设置标记位true
                //非阻塞中断 只是设置标记位true
                if(interruptStatus){
                //如果中断为true则退出
                    break;
                }
               
            } catch (InterruptedException e) {
                
                // 一个线程在运行状态中，其中断标志被设置为true之后，一旦线程调用了
                // wait、join、sleep方法中的一种，立马抛出一个InterruptedException，且中断标志被程序会自动清除，重新设置为false
                System.out.println("阻塞中断"+Thread.currentThread().isInterrupted());//显示false并抛异常
                return;//不想返回还可继续写代码
            }
        }
      }
   
  }
  
  子线程循环第1次false
  子线程循环第2次false
  子线程循环第3次false
  阻塞中断false
  

• Stop()停止

  • 由于不安全，已经不使用了，因为stop会解除由线程获取的所有锁定，当在一个线程对象上调用stop()方法时，这个线程对象所运行的线程就会立即停止，假如一个线程正在执行：synchronized void { x = 3; y = 4;}由于方法是同步的， 多个线程访问时总能保证x,y被同时赋值，而如果一个线程正在执行到x = 3;时，被调用了 stop()方法，即使在同步块中，它也会马上stop了，这样就产生了不完整的残废数据。

• 设置标记位停止

public class TestThread2_1 {
    public static void main(String[] args) throws InterruptedException {
        MyThreads my = new MyThreads();
        new Thread(my, "线程A").start();
        Thread.sleep(10000);
        //设置标记位
        //my.setFlag(false);

        //stop方法
        new Thread(my, "线程A").stop();
        System.out.println("代码结束");

    }
}

class MyThreads implements Runnable {
    private boolean flag = true;

    @Override
    public void run() {
        int i = 1;
        while (flag) {
            try {
                Thread.sleep(1000);
                System.out.println("第" + i + "次执行，线程名称为：" + Thread.currentThread().getName());
                i++;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

多线程控制类

ThreadLocal类(关于这个类后续会推出关于这个类的专题)

• 用处: 保存线程的独立变量, 对一个下线程类使用ThreadLocal维护变量时,ThreadLocal为每个使用该变量的线程单独提供了独立的变量,所以每个线程都可以独立地改变自己的副本,而不会影响其他线程所对应的副本,长用于用户登录控制,如记录session信息

• 常用方法

  方法	作用
  initValue()	副本创建的方法
  get()	得到副本
  set()	设置副本

• 实例

  • ThreadLocal能实现为不同的线程保存变量的原理是，它内部有个Entry,保存<线程名，变量值>,不同的线程对应着不同的value,就能加以区分了

  public class ThreadLocalDemo {
    //银行对象，有钱，有存款和取款两个操作
    static class Bank{
        ThreadLocal<Float> threadLocal = new ThreadLocal<Float>() {
            protected Float initialValue() {
                return 0.0f;
            }
            
        };
        //存款
        public Float get() {
            return threadLocal.get();
        }
        //取款
        public void set(Float money) {
            threadLocal.set(threadLocal.get()+money);
        }
    }
    
    
    //转账对象，从银行中取钱然后转账，然后保存到账户
    static class Transfer implements Runnable{
        private Bank bank;
        public Transfer(Bank bank){
            this.bank = bank;
        }
        
        @Override
        public void run() {
            // TODO Auto-generated method stub
            for(int i = 0;i<10;i++) {
                bank.set(10.0f);
                System.out.println(Thread.currentThread().getName()+"账户余额"+bank.get());
            }
        }
    }
  }
  //main 中 模拟操作
        Bank bank = new Bank();
        Transfer transfer = new Transfer(bank);
        Thread t1 =new Thread(transfer,"客户1");
        Thread t2 =new Thread(transfer,"客户2");
        t1.start();
        t2.start();
  

Lock类

• Lock类实际上是一个接口，我们在实例化的时候实际上是实例化实现了该接口的类

Lock lock = new ReentrantLock();

• 作用 :通过Lock对象lock，用lock.lock来加锁 用lock.unlock来释放锁。在两者中间放置需要同步处理的代码。

  • 可重入锁(ReentrantLock): 线程请求它已经拥有的锁时不会阻塞，可以进入它已经拥有的同步代码块，但是它拥有了多少次，就要解锁多少次才能释放锁
  • 读写锁(ReadWriteLock) :可以同时读，但是读的时候不能写，也不能同时写，写的时候不能读

  public class MyConditionService {
      private Lock lock = new ReentrantLock();//ReentrantLock是个重入锁
      public void testMethod(){
          lock.lock();//加锁
          for (int i = 0 ;i < 5;i++){
              System.out.println("ThreadName = " + Thread.currentThread().getName() + (" " + (i + 1)));
          }
          lock.unlock();//解锁
      }
  }
  

• 其他作用

  • 实现锁的公平
  • 获取当前线程调用lock的次数，也就是获取当前线程锁定的个数
  • 获取等待锁的线程数
  • 查询指定的线程是否等待获取此锁定
  • 查询是否有线程等待获取此锁
  • 查询当前线程是否持有锁定
  • 判断一个锁是不是被线程持有
  • 加锁时如果中断则不加锁，进入异常处理
  • 尝试加锁，如果该锁未被其他线程持有的情况下成功

• Condition类

• Condition是Java提供了来实现等待/通知的类，Condition类还提供比wait/notify更丰富的功能，Condition对象是由lock对象所创建的。但是同一个锁可以创建多个Condition的对象，即创建多个对象监视器。这样的好处就是可以指定唤醒线程。notify唤醒的线程是随机唤醒一个。

• condition对象通过lock.newCondition()来创建，用condition.await()来实现让线程等待，使得线程进入阻塞。用condition.signal()来实现唤醒线程。唤醒的线程是用同一个conditon对象调用await()方法而进入阻塞。并且和wait/notify一样，await()和signal()也是在同步代码区内执行。
  对于等待/通知机制，简化而言，就是等待一个条件，当条件不满足时，就进入等待，等条件满足时，就通知等待的线程开始执行。为了实现这种功能，需要进行wait的代码部分与需要进行通知的代码部分必须放在同一个对象监视器里面。执行才能实现多个阻塞的线程同步执行代码，等待与通知的线程也是同步进行。对于wait/notify而言，对象监视器与等待条件结合在一起 即synchronized（对象）利用该对象去调用wait以及notify。但是对于``Condition类，是对象监视器与条件分开，Lock类来实现对象监视器，condition`对象来负责条件，去调用await以及signal。

• 示例代码:

  public class ConditionWaitNotifyService {
  
      private Lock lock = new ReentrantLock();
  
      public Condition condition = lock.newCondition();
  
  
      public void await(){
          try{
              lock.lock();
              System.out.println("await的时间为 " + System.currentTimeMillis());
              condition.await();
              System.out.println("await结束的时间" + System.currentTimeMillis());
  
          }catch (Exception e){
              e.printStackTrace();
          }finally {
              lock.unlock();
          }
      }
  
  
      public void signal(){
          try{
              lock.lock();
              System.out.println("sign的时间为" + System.currentTimeMillis());
              condition.signal();
          }finally {
              lock.unlock();
          }
      }
  
      public static void main(String[] args) throws InterruptedException {
  
          ConditionWaitNotifyService service = new ConditionWaitNotifyService();
          new Thread(service::await).start();
          Thread.sleep(1000 * 3);
          service.signal();
          Thread.sleep(1000);
  
      }
  }
  

  • 其他作用:和wait类提供了一个最长等待时间，awaitUntil（Date deadline）在到达指定时间之后，线程会自动唤醒。但是无论是await或者awaitUntil，当线程中断时，进行阻塞的线程会产生中断异常。Java提供了一个awaitUninterruptibly的方法，使即使线程中断时，进行阻塞的线程也不会产生中断异常。