多线程学习

一、多线程

1.什么叫多线程？

线程是程序中执行的线程，Java虚拟机允许程序同时运行多个执行线程。

2.线程与进程

进程： 是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间。
线程： 是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行，一个进程最少有一个线程。
  线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程。

3.线程调度

分时调度： 所有线程轮流使用CPU的使用权，平均分配每个线程占用的CPU的时间。
抢占式调度： 优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个（线程的随机性）
  在Java中使用的为抢占式调度
  CPU使用抢占式调度模式在多个线程间进行者高速的切换。对于CPU的一个核心而言，某个时刻，只能执行一个线程，而CPU在多个线程间切换速度相对于我们的感觉要快，看上去就是在统一时刻运行。其实，多线程程序并不能提高程序的运行速度，但能提高程序的运行效率，让CPU的使用率更高。

4.同步与异步

同步： 排队执行，效率低但是安全。
异步： 同时执行，效率高但是数据不安全。

5.并发与并行

并发： 指两个或多个事件在同一时间段内发生。
并行： 指两个或多个事件在同一时刻发生（同时发生）

二、继承Thread

class Test {
    /**
     *  run方法就是线程要执行的任务方法
     */
    public static void main(String[] args){
        new MyThread().start();
        for (int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"床前明月光"+i);
        }
    }

    static class MyThread extends Thread{
        //这里的代码，就是一条新的执行路径
        //这个执行路径的触发方式，不是调用run方法，而是通过thread对象的start（）来启动任务的
        @Override
        public void run() {
            for (int i=0;i<10;i++){
                System.out.println(Thread.currentThread().getName()+"疑是地上霜"+i);
            }
        }
    }
}

   1）start方法
   start()用来启动一个线程，当调用start方法后，系统才会开启一个新的线程来执行用户定义的子任务，在这个过程中，会为相应的线程分配需要的资源。

   2）run方法
   run()方法是不需要用户来调用的，当通过start方法启动一个线程之后，当线程获得了CPU执行时间，便进入run方法体去执行具体的任务。注意，继承Thread类必须重写run方法，在run方法中定义具体要执行的任务。

以下是运行结果：

第一次运行结果：

第二次运行结果：

第三次运行结果：

   多次运行后可以发现每次运行结果都不相同。因为Thread是并发执行，抢占式调度（谁抢的过谁就先执行）。

三、实现Runnable

 多线程技术
 实现Runnable与继承Thread相比有如下优势：
   1.通过创建任务，然后给线程分配的方式来实现的多线程，更适合多个线程同时执行相同任务的情况。（Thread也不是不可以）
   2.可以避免单继承所带来的局限性。
   3.任务与线程本身是分离的，提高了程序的健壮性。
   4.为之后学习的线程池技术，接受Runnable类型的任务，不接收Thread类型的任务。

class Test {
    public static void main(String[] args) {
        //实现Runnable
        //1.    创建一个任务对象
        Runnable r = new MyRunnable();
        //2.    创建一个线程，为其分配一个任务
        Thread t = new Thread(r);
        //3.    执行这个任务
        t.start();
        for (int i=0;i<10;i++){
            System.out.println("床前明月光"+i);
        }
    }

    static class MyRunnable implements Runnable{
        @Override
        public void run() {
            for (int i=0;i<10;i++){
                System.out.println("疑是地上霜"+i);
            }
        }
    }
}

以下为运行结果：

第一次运行：

第二次运行：

  从上运行结果可以看出两者差异不是很大，但更推荐使用Runnable，不仅是为了之后的线程池做准备，主要是Runnable可以达到资源共享的目的。（继承thread确实无法共享资源，之所以传参的哪种方式可以实现共享，是因为继承thread类本质上还是实现了Runnable接口，所以他才能使用传参的那种方式创建线程，也就是说本质上还是Runnable实现的资源共享。）

四、设置和获取线程名称

Thread.currentThread().getName();

以下为运行代码：

class Test {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName());
        Runnable r = new MyRunnable();
        Thread t1 = new Thread(r);
        t1.start();
    }

    static class MyRunnable implements Runnable{

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName());
        }
    }
}

运行结果：

  这就是当前运行线程的名称。

五、线程休眠sleep

Thread.sleep(3000);

以下为运行代码：

class Test {
    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
}

  值得注意的是sleep的休眠时间是以毫秒计算的。

六、守护线程

1.何为守护线程

  守护线程（即daemon thread），是个服务线程，准确地来说就是服务其他的线程。
  当非守护线程停止,守护线程才停止。

2.守护线程的作用

  （1）线程：分为守护线程和用户线程
  （2）用户线程：当一个进程不包含任何的存活的线程时，运行结束。
  （3）守护线程：守护用户线程的，当最后一个用户线程结束时，所有守护线程自动死亡。

让我们来看看下面两个案例：
  正常情况下，只有两个线程都全部运行完毕，程序才会停止，但如果将其中一个命名为守护线程，就会发生变化。

正常情况：

class Test {
    public static void main(String[] args) {
        Runnable r = new MyRunnable();
        Thread t1 = new Thread(r);
        t1.start();
        for (int i=0;i<=5;i++){
            System.out.println(Thread.currentThread().getName()+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


    static class MyRunnable implements Runnable{

        @Override
        public void run() {
            for (int i=0;i<=10;i++){
                System.out.println(Thread.currentThread().getName()+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

运行结果：

加入守护线程后：

class Test {
    public static void main(String[] args) {
        Runnable r = new MyRunnable();
        Thread t1 = new Thread(r);
        //设置t1为守护线程
        t1.setDaemon(true);
        t1.start();
        for (int i=0;i<=5;i++){
            System.out.println(Thread.currentThread().getName()+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


    static class MyRunnable implements Runnable{

        @Override
        public void run() {
            for (int i=0;i<=10;i++){
                System.out.println(Thread.currentThread().getName()+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

运行结果：

  能看出来明显与上面不一样了，把t1设为守护线程，main方法就成了用户线程，t1所调用的MyRunnable中的run方法本来是循环10次自动停止的，但由于main方法只循环了5次就结束了，这时守护线程t1中的所有用户线程全部结束了，所有的守护线程（t1）也就自动死亡了。

七、线程安全

1.何为线程安全

  当多个线程访问某个方法时，不管你通过怎样的调用方式、或者说这些线程如何交替地执行，我们在主程序中不需要去做任何的同步，这个类的结果行为都是我们设想的正确行为，那么我们就可以说这个类是线程安全的。
  既然都说到了线程安全，那肯定就有不安全，下面我们来看这一组代码。

class Test {
    static int count = 1;
    public static void main(String[] args) {
        for (int i=0;i<5;i++){
            new Thread(new MyRunnable()).start();
            new Thread(new MyRunnable()).start();
            new Thread(new MyRunnable()).start();
            new Thread(new MyRunnable()).start();
            new Thread(new MyRunnable()).start();
            new Thread(new MyRunnable()).start();
            new Thread(new MyRunnable()).start();
        }
    }


    static class MyRunnable implements Runnable{
        @Override
        public void run() {
            count++;
            System.out.println(count);
        }
    }
}

  看上去是不是感觉平平无奇，感觉没有什么问题，但运行起来你就会发现问题很大。
运行结果：

  从图中我们可以明显的看到有两个17，没错，这就是线程的不安全。
  这也是我们最常见的一种，就是我们A线程在进入方法后，拿到了count的值，刚把这个值读取出来，还没有改变count的值的时候，结果线程B也进来的，那么导致线程A和线程B拿到的count值是一样的。就出现了图上的这种情况。

2.如何确保线程安全

（1）synchronized

  synchronized关键字，就是用来控制线程同步的，保证我们的线程在多线程环境下，不被多个线程同时执行，确保我们数据的完整性，使用方法一般是加在方法上。

public synchronized void run() {
            count++;
            System.out.println(count);
        }

  这样就可以确保我们的线程同步了，同时这里需要注意一个大家平时忽略的问题，首先synchronized锁的是括号里的对象，而不是代码。

  当synchronized锁住一个对象之后，别的线程如果想要获取锁对象，那么就必须等这个线程执行完释放锁对象之后才可以，否则一直处于等待状态。

（2）显示锁Lock

  上面讲的synchronized属于隐式锁，而这个Lock就属于显示锁了，什么意思？就是说synchronized虽说也是一把锁，但是一把看不见的锁，不是我们自己亲自上的锁，而是在系统里自己添加的，我们看不见的锁，而Lock是属于我们自己亲自上的锁，可以自由选择上锁区域，但正因为使我们自己上的锁，所以在上完锁的后面还要解开锁。

class Test {
    static int count = 1;
    public static void main(String[] args) {
        Runnable r = new MyRunnable();
        new Thread(r).start();
        new Thread(r).start();
        new Thread(r).start();
    }


    static class MyRunnable implements Runnable{
        private int count = 10;
        private Lock l = new ReentrantLock();
        @Override
        public void run() {
            while(true){
            	//上锁
                l.lock();
                if (count>0){
                    System.out.println("正准备买票");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count--;
                    System.out.println("出票成功"+Thread.currentThread().getName()+"余票:"+count);
                    //开锁
                    l.unlock();
                }
            }
        }
    }
}

运行结果：

  由此也可以看出Lock也能保护我们线程安全，但可能会有细心的小伙伴问了，你这上面运行结果不都是一个线程在运行吗？其实并不是，正如前面所说，Lock是我们自己来上锁，我们让程序上了一把锁，但现在有三个线程，于是他们三个要抢这一把锁（抢占式分配嘛，谁抢得过就谁先运行），图中正巧被Thread-2抢到了，于是他带着锁运行了，运行完毕之后，开锁了，他们三又可以抢了，但因为是Thread-2开的锁嘛，肯定他离得最近，所以他又抢到锁了，继续运行。

  最后在说一下，由于博主我也算是新人，所以我文章里有什么错误以及语言或逻辑上的问题，还请各位大佬能够指出来，再次感激不尽。