多线程面试重点，显式锁和隐示锁的区别

Java中有关多线程相关的知识点

1.进程 和 线程 之间的区别是什么?
简单来说，进程是程序运行和资源分配的基本单位，一个程序至少有一个进程，而一个进程至少有一个线程。进程在执行过程中拥有独立的内存单元，而多个线程共享内存资源，这样可以减少切换次数，从而效率更高。线程是进程的一个实体，是cpu调度和分派的基本单位,是比程序更小的能独立运行的基本单位。同一进程中的多个线程之间可以并发执行。

2 .java中实现多线程的几种方式
java中实现多线程的方式主要有两种，第一种是继承Thread类，第二种是实现Runnable接口。
实现Runnable与继承Thread相比有如下优势：
1 通过创建任务，然后给线程分配的方式来实现多线程。更适合多个线程同时执行相同任务的情况
2可以避免单继承带来的局限性
3任务与线程本身是分离的，提高了程序的健壮性
4线程池技术中接受Runnable类型的任务，不接受Thread类型的线程。

3 线程分为：守护线程和用户线程
用户线程：当一个进程不包含任何的存活的用户线程时，进程结束。
守护线程：守护用户线程的，当最后一个用户线程结束时，所有守护线程自动死亡
面试中可能遇到：守护线程和用户线程之间的区别
程序运行完毕，jvm会等待非守护线程完成后关闭，但是jvm不会等待守护线程。守护线程最典型的例子就是GC线程。

4 sleep 和 wait之间的区别
两者最主要的区别是sleep没有释放锁，只是让当前线程进入睡眠状态，wait会交出锁进入等待状态，别的线程可以工作

5 synchronized 和 lock 之间的区别
synchronized和lock的区别主要从两个方面讲，从用法上，synchronized可以加载类上，方法上，属性上，要指定锁住的对象。而lock要指定起始位置和终止位置。从性能上，synchronized是依赖于jvm，而lock依赖于我们的java代码，比起synchronized属于轻量级操作，所以在并发量比较小的情况下，使用synchronized是个不错的选择，但是在并发量比较高的情况下，其性能下降很严重，此时Lock是个不错的方案

Java使用的是抢占式调度
同步（排队执行，效率低但是安全）
异步（同时执行，效率高但是不安全）
最后总结线程安全问题
保证线程安全的三种方式：同步代码块，同步方法以及显示锁
其中同步代码块和同步方法属于隐示锁，显示锁Lock的常用子类ReentrantLock

1、同步的关键是要为代码加上“锁”，同步代码块是指使用synthronized关键字定义的代码块，在该地阿玛执行时往往需要设置一个同步对象，由于线程操作的不确定状态，这个时候同步对象可以选择this. 下面以卖票操作进行举例（3个线程卖3张票）

public class Demo0001 {
    public static void main(String[] args) {
        MyThread r = new MyThread();
        //创建三个线程执行售票任务
        new Thread(r,"售货员A").start(); //开启卖票线程
        new Thread(r,"售货员B").start(); //开启卖票线程
        new Thread(r,"售货员C").start(); //开启卖票线程
    }
    //实现Runnable接口
     static  class MyThread  implements Runnable{
        private int count = 3;
        @Override
        public void run() {//重写run任务 - 售票任务
            while (true) {
                synchronized (this) {//synchronized关键字 传入唯一的锁对象，同步代码块
                    if (count > 0) {   //还有剩余票
                        try {          //模拟网络延迟
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() +
                                "卖票，ticket = " + count--);
                    }else {
                        System.out.println("********票已经卖光了************");
                        break;
                    }
                }
            }
        }
    }
}

程序的运行效果如下：

2使用同步方法
如果现在某一个方法中的全部操作都需要进行同步处理，则可以采用同步方法的形式进行定义，即在方法声明上使用synchronized关键字即可。对应代码如下：

public class Demo0001 {
    public static void main(String[] args) {
        MyThread r = new MyThread();
        //创建三个线程执行售票任务
        new Thread(r,"售货员A").start(); //开启卖票线程
        new Thread(r,"售货员B").start(); //开启卖票线程
        new Thread(r,"售货员C").start(); //开启卖票线程
    }
    //实现Runnable接口
     static  class MyThread  implements Runnable{
        private int count = 3;
        @Override
        public void run() {//重写run任务 - 售票任务
            while(this.sale()){

            }
        }

     public synchronized  boolean sale () {//synchronized关键字 传入唯一的锁对象，同步方法
         if (count > 0) {   //还有剩余票
             try {          //模拟网络延迟
                 Thread.sleep(100);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             System.out.println(Thread.currentThread().getName() +
                     "卖票，ticket = " + count--);
             return true;
         } else {
             System.out.println("********票已经卖光了************");
             return false;
         }

        }
     }

}

运行结果为：

3使用显示锁
显示锁使用的是Lock类下的一个子类ReentrantLock类，原理就是由程序员创建锁/关闭锁。对应的程序如下：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Demo0001 {
    public static void main(String[] args) {
        MyThread r = new MyThread();
        //创建三个线程执行售票任务
        new Thread(r,"售货员A").start(); //开启卖票线程
        new Thread(r,"售货员B").start(); //开启卖票线程
        new Thread(r,"售货员C").start(); //开启卖票线程
    }
    //实现Runnable接口
     static  class MyThread  implements Runnable {
        private int count = 3;
        private Lock lock = new ReentrantLock(); //创建锁对象lock

        @Override
        public void run() {//重写run任务 - 售票任务
            while (true) {
                lock.lock();  //程序员自己创建锁
                if (count > 0) {   //还有剩余票
                    try {          //模拟网络延迟
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() +
                            "卖票，ticket = " + count--);
                } else {
                    break;
                }
                lock.unlock(); //程序员自己关闭锁
            }
        }
    }
}

程序运行结果图：