多线程~再学习

多线程安全问题的原因：

通过图解：发现一个线程在执行多条语句时，并运算同一个数据时，在执行过程中，其他线程参与进来，并操作了这个数据。导致到了错误数据的产生。

涉及到两个因素：

1，多个线程在操作共享数据。
2，有多条语句对共享数据进行运算。
原因：多条语句，在某一个时刻被一个线程执行时，还没有执行完，就被其他线程执行了。

解决安全问题的原理：

只要将操作共享数据的语句在某一时段让一个线程执行完，在执行过程中，其他线程不能进来执行就可以解决这个问题。

如何进行多句操作共享数据代码的封装呢？

java中提供了一个解决方式：就是同步代码块。（隐式锁）

格式：
synchronized(对象) { // 任意对象都可以。这个对象就是锁。
需要被同步的代码；
}

package com.java.demo4;
public class Demo2 {
    //线程不安全
    //解决方案1，同步代码块
    //格式：
    public static void main(String[] args) {
        Object o = new Object();
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable {
        private int count = 10;
        private Object o = new Object();
        public void run() {
            Object o = new Object();
            while (true) {
                synchronized (o) {
                    if (count > 0) {
                        //卖票
                        System.out.println("正在准备卖票");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        count--;
                        System.out.println(Thread.currentThread().getName() + "成功出票，余票" + count);
                    } else {
                        break;
                    }
                }
            }
        }
    }
}

运行结果

正在准备卖票
Thread-1成功出票，余票9
正在准备卖票
Thread-1成功出票，余票8
正在准备卖票
Thread-1成功出票，余票7
正在准备卖票
Thread-1成功出票，余票6
正在准备卖票
Thread-1成功出票，余票5
正在准备卖票
Thread-1成功出票，余票4
正在准备卖票
Thread-1成功出票，余票3
正在准备卖票
Thread-1成功出票，余票2
正在准备卖票
Thread-1成功出票，余票1
正在准备卖票
Thread-1成功出票，余票0

Process finished with exit code 0

同步：排队执行，效率低但是安全

就是在操作共享数据代码时，访问时只能让一个线程进去访问，此线程执行完退出后，别的线程才能再对此共享数据代码进行访问。
好处：解决了线程安全问题。Synchronized
弊端：相对降低性能，因为判断锁需要消耗资源，产生了死锁。

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

就是彼此独立,在等待某事件的过程中继续做自己的事，不需要等待这一事件完成后再工作。

并发：指两个或多个事件在同一时间段内发生

在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行。其中两种并发关系分别是同步和互斥

并行：指两个或多个事件在同一时刻发生

在单处理器中多道程序设计系统中，进程被交替执行，表现出一种并发的外部特种；在多处理器系统中，进程不仅可以交替执行，而且可以重叠执行。在多处理器上的程序才可实现并行处理。从而可知，并行是针对多处理器而言的。并行是同时发生的多个并发事件，具有并发的含义，但并发不一定并行，也亦是说并发事件之间不一定要同一时刻发生。

定义同步是有前提的：

1，必须要有两个或者两个以上的线程，才需要同步。
2，多个线程必须保证使用的是同一个锁。

同步的第二种表现形式：同步方法(隐式锁)

就是将同步关键字定义在函数上，让函数具备了同步性。

扫描二维码关注公众号，回复： 11444978 查看本文章

package com.java.demo4;
public class Demo3 {
    //线程不安全
    //解决方案2，同步方法
    //格式：
    public static void main(String[] args) {
        Object o = new Object();
        Runnable run = new com.java.demo4.Demo2.Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable {
        private int count = 10;
        private Object o = new Object();

        public void run() {
            while (true) {
                boolean flag = sale();
                if (!flag) {
                    break;
                }
            }
        }

        public synchronized boolean sale() {
            if (count > 0) {
                //卖票
                System.out.println("正在准备卖票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println(Thread.currentThread().getName() + "成功出票，余票" + count);
                return true;
            }
            return false;
        }
    }
}

运行结果

正在准备卖票
Thread-0成功出票，余票9
正在准备卖票
Thread-0成功出票，余票8
正在准备卖票
Thread-0成功出票，余票7
正在准备卖票
Thread-0成功出票，余票6
正在准备卖票
Thread-0成功出票，余票5
正在准备卖票
Thread-1成功出票，余票4
正在准备卖票
Thread-1成功出票，余票3
正在准备卖票
Thread-1成功出票，余票2
正在准备卖票
Thread-1成功出票，余票1
正在准备卖票
Thread-1成功出票，余票0

Process finished with exit code 0

同步函数是用的哪个锁呢？

synchronized(this)用以定义需要进行同步的某一部分代码块
通过验证，函数都有自己所属的对象this，所以同步函数所使用的锁就是this锁。This.方法名

当同步函数被static修饰时，这时的同步用的是哪个锁呢？

静态函数在加载时所属于类，这时有可能还没有该类产生的对象，但是该类的字节码文件加载进内存就已经被封装成了对象，这个对象就是该类的字节码文件对象。
所以静态加载时，只有一个对象存在，那么静态同步函数就使用的这个对象。
这个对象就是 类名.class

同步代码块和同步函数的区别？

同步代码块使用的锁可以是任意对象。
同步函数使用的锁是this，静态同步函数的锁是该类的字节码文件对象。

在一个类中只有一个同步的话，可以使用同步函数。如果有多同步，必须使用同步代码块，来确定不同的锁。所以同步代码块相对灵活一些。

考点问题：请写一个延迟加载的单例模式？写懒汉式；当出现多线程访问时怎么解决？加同步，解决安全问题；效率高吗？不高；怎样解决？通过双重判断的形式解决。

懒汉式：延迟加载方式。
当多线程访问懒汉式时，因为懒汉式的方法内对共性数据进行多条语句的操作。所以容易出现线程安全问题。为了解决，加入同步机制，解决安全问题。但是却带来了效率降低。
为了效率问题，通过双重判断的形式解决。

public static Singleton getInstance() {
        if (singleton == null) {  
            synchronized (Singleton.class) {  
               if (singleton == null) {  
                  singleton = new Singleton(); 
               }  
            }  
        }  
        return singleton; 
    }

同步死锁：

通常只要将同步进行嵌套，就可以看到现象。同步函数中有同步代码块，同步代码块中还有同步函数。

线程间通信：

思路：多个线程在操作同一个资源，但是操作的动作却不一样。
1：将资源封装成对象。
2：将线程执行的任务(任务其实就是run方法。)也封装成对象。

等待唤醒机制：

涉及的方法：
wait:将同步中的线程处于冻结状态。释放了执行权，释放了资格。同时将线程对象存储到线程池中。
notify：唤醒线程池中某一个等待线程。
notifyAll:唤醒的是线程池中的所有线程。

注意：
1：这些方法都需要定义在同步中。
2：因为这些方法必须要标示所属的锁。
你要知道 A锁上的线程被wait了,那这个线程就相当于处于A锁的线程池中，只能A锁的notify唤醒。
3：这三个方法都定义在Object类中。为什么操作线程的方法定义在Object类中？
因为这三个方法都需要定义同步内，并标示所属的同步锁，既然被锁调用，而锁又可以是任意对象，那么能被任意对象调用的方法一定定义在Object类中。

wait和sleep区别：

分析这两个方法：从执行权和锁上来分析：
wait：可以指定时间也可以不指定时间。不指定时间，只能由对应的***notify***或者***notifyAll***来唤醒。
sleep：必须指定时间，时间到自动从冻结状态转成运行状态(临时阻塞状态)。
wait：线程会释放执行权，而且线程会释放锁。
Sleep：线程会释放执行权，但不是不释放锁。

LOCK的出现替代了同步：lock.lock();………lock.unlock();

Lock接口：（显式锁）

同步是隐示的锁操作，而Lock对象是显示的锁操作。

在之前的版本中使用Object类中wait、notify、notifyAll的方式来完成的。那是因为同步中的锁是任意对象，所以操作锁的等待唤醒的方法都定义在Object类中。

而现在锁是指定对象Lock。所以查找等待唤醒机制方式需要通过Lock接口来完成。而Lock接口中并没有直接操作等待唤醒的方法，而是将这些方式又单独封装到了一个对象中。这个对象就是Condition，将Object中的三个方法进行单独的封装。并提供了功能一致的方法 await()、signal()、signalAll()体现新版本对象的好处。

package com.java.demo4;

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

public class Demo4 {
    //线程不安全
    //解决方案3:Lock(显式锁)
    //格式：
    public static void main(String[] args) {
        Object o = new Object();
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable {
        private int count = 10;
        //显式锁
        Lock l = new ReentrantLock();
        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);
                } else {
                    break;
                }
                l.unlock();
            }
        }
    }
}

运行结果

正在准备卖票
Thread-2成功出票，余票9
正在准备卖票
Thread-2成功出票，余票8
正在准备卖票
Thread-2成功出票，余票7
正在准备卖票
Thread-2成功出票，余票6
正在准备卖票
Thread-2成功出票，余票5
正在准备卖票
Thread-0成功出票，余票4
正在准备卖票
Thread-0成功出票，余票3
正在准备卖票
Thread-0成功出票，余票2
正在准备卖票
Thread-0成功出票，余票1
正在准备卖票
Thread-0成功出票，余票0