JAVASE(20)多线程

1.多线程程序实现

多线程程序实现的方式1

public class MyThread extends Thread{
    @Override
    //继承Thread类
    //重写run( )方法
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
        }
    }
}
public class Demo1 {
    public static void main(String[] args) throws InterruptedException {
        MyThread myThread = new MyThread();
        //创建一个继承了Thread类的对象
        myThread.start();
        //开启线程
    }
}

多线程程序实现的方式2

public class Runnableclass implements Runnable {
    //实现Runnable接口
    //重写run( )方法
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
        }
    }
}
public class Demo2 {
    public static void main(String[] args) {
        Runnableclass runnableclass = new Runnableclass();
        //创建一个实现runnable接口类的对象
        Thread thread = new Thread(runnableclass);
        //利用Thread的有参构造的方法将对象传进去
        thread.start();
        //开启线程
    }
}
//可以避免单继承带来的局限性

多线程程序实现的方式3

public class Callableclass implements Callable {
    //继承callable接口
    //重写call（）方法
    static int sum=0;
    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 10; i++) {
            sum+=i;
        }
        return sum;
    }
}
public class Demo3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callableclass callableclass = new Callableclass();
        //创建一个类继承callable接口
        FutureTask<Integer> futureTask = new FutureTask<Integer>(callableclass);
        //创建一个FutureTask的对象将继承了callzble接口的对象传进去
        Thread thread = new Thread(futureTask);
        //调用Thread中的有参构造，将futureTask的对象传进去
        thread.start();
        //开启线程
        Integer integer = futureTask.get();
        //获取子线程中的返回值
    }
}

2.案例

继承Thread类的方式卖电影票案例

案例演示
需求：某电影院目前正在上映贺岁大片，共有100张票，而它有3个售票窗口售票，请设计一个程序模拟该电影院售票。通过继承Thread类实现

分析:
a: 三个窗口其实就是3个线程
b: 定义票的数量100张
c: 创建线程对象,启动线程. 每卖一张这个票数应该

public class MyThread extends Thread{
    static int piao=100;
    //要将票数设置成为共享的变量，不然会出现下一个进程进来的时候，票值都会被重新设置为100
    @Override
    public void run() {
        while (piao>=1){
            System.out.println(this.getName()+"售卖"+(piao--)+"张");
        }
    }
}
public class Demo {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

实现Runnable接口的方式卖电影票

案例演示
需求：某电影院目前正在上映贺岁大片，共有100张票，而它有3个售票窗口售票，请设计一个程序模拟该电影院售票。
通过实现Runnable接口实现

public class Myrunnable implements Runnable{
    int piao =100;
    @Override
    public void run() {
        while (piao>=1){
            String name = Thread.currentThread().getName();
            //使用Thread中的静态方法，currentThread的方法，是现进程
            System.out.println(name+"售卖"+(piao--)+"张");
        }
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Myrunnable myrunnable = new Myrunnable();
        Thread t1 = new Thread(myrunnable);
        Thread t2 = new Thread(myrunnable);
        Thread t3= new Thread(myrunnable);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

买电影票出现了同票和负数票的原因分析

加入延迟
我们前面讲解过电影院售票程序，从表面上看不出什么问题，但是在真实生活中，售票时网络是不能实时传输的，总是存在延迟的情况，所以，在出售一张票以后，需要一点时间的延迟改实现接口方式的卖票程序,每次卖票延迟100毫秒
B:出现问题了问题

public class Myrunnable implements Runnable {
    int piao = 10000;
    @Override
    public void run() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        while (true) {
            if (piao >=1) {
                String name = Thread.currentThread().getName();
                //使用Thread中的静态方法，currentThread的方法，是现进程
                System.out.println(name + "售卖" + (piao--) + "张");
            }
        }
    }
}

3.同步代码块的方式解决线程安全问题

同步代码块的格式：

synchronized(对象){
		需要同步的代码;
	}

同步可以解决安全问题的根本原因就在那个对象上，该对象如同锁的功能。在java编程中，经常需要用到同步，而用得最多的也许是synchronized关键字了，因为synchronized关键字涉及到锁的概念，所以先来了解一些相关的锁知识。
java的内置锁：每个java对象都可以用做一个实现同步的锁，这些锁成为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。 获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。java内置锁是一个互斥锁，这就是意味着最多只有一个线程能够获得该锁。

当线程A尝试去获得线程B持有的内置锁时，线程A必须等待或者阻塞，直到线程B释放这个锁，如果B线程不释放这个锁，那么A线程将永远等待下去。

java的对象锁和类锁：java的对象锁和类锁在锁的概念上基本上和内置锁是一致的，但是，两个锁实际是有很大的区别的，对象锁是用于对象实例方法，或者一个对象实例上的，类锁是用于类的静态方法或者一个类的class对象上的。我们知道，类的对象实例可以有很多个，但是每个类只有一个class对象，所以不同对象实例的对象锁是互不干扰的，但是每个类只有一个类锁。但是有一点必须注意的是，其实类锁只是一个概念上的东西，并不是真实存在的，它只是用来帮助我们理解锁定实例方法和静态方法的区别的。

public class Myrunnable implements Runnable {
    int piao = 10000;
    Object obj = new Object();
    //定义锁
    <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
    @Override
    public void run() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
            while (true) {
                synchronized (obj) {
                if (piao >= 1) {
                    String name = Thread.currentThread().getName();
                    //使用Thread中的静态方法，currentThread的方法，是现进程
                    System.out.println(name + "售卖" + (piao--) + "张");
                }
            }
        }
    }
}

4.Lock锁的概述和使用

Lock锁的概述
虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock

Lock和ReentrantLock
void lock()
void unlock()

public class Myrunnable implements Runnable {
    int piao = 10000;
    ReentrantLock lock = new ReentrantLock();

    //定义锁
    @Override
    public void run() {
        lock.lock();
        while (true) {
            try {
                lock.lock();//创建一个锁，上锁
                if (piao >= 1) {
                    String name = Thread.currentThread().getName();
                    //使用Thread中的静态方法，currentThread的方法，是现进程
                    System.out.println(name + "售卖" + (piao--) + "张");
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();//对象锁必须放在catch中才能使用
                //释放锁
            }
        }
    }
}

5.死锁问题概述和使用

public class Myrunnableclass implements Runnable {
    boolean flag;
    static Object obja = new Object();//创建一个锁对象
    static Object objb = new Object();//创建一个锁对象
    public Myrunnableclass(boolean flag) {
        this.flag = flag;
    }
    //有参构造，设置传入一个boolean类型的数据
    @Override
    public void run() {
        if (flag) {
            synchronized (obja) {
                //使用a锁
                System.out.println("a锁使用了");
                synchronized (objb) {
                    //判断是否可以使用b锁，因为其他进程可能会占用b锁
                    //当其他进程使用b锁时，因为锁的互斥性，此进程会阻塞
                    //同理，就会产生死锁
                    System.out.println("b锁使用了");
                }
            }
        } else {
            synchronized (objb) {
                //使用b锁
                System.out.println("b锁使用了");
                synchronized (obja) {
                    System.out.println("a锁使用了");
                    //判断是否可以使用a锁，因为其他进程可能会占用a锁
                }
            }
        }
    }
}
public class Demo2 {
    public static void main(String[] args) {
        Myrunnableclass a = new Myrunnableclass(true);
        Myrunnableclass b = new Myrunnableclass(false);
        Thread A = new Thread(a);
        Thread B = new Thread(b);
        A.start();
        B.start();
    }
}
//注意：死锁不是每次都会出现，这个和内存的占用有关