多线程

Lock锁

01.JDK5之后Lock锁的使用虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁， 为了更清晰的表达如何加锁和释放锁,JDK5以后提供了一个新的锁对象Lock。Lock：    void lock()： 获取锁。    void unlock():释放锁。  ReentrantLock是Lock的实现类. 

public class SellTicket implements Runnable {    // 定义票    private int tickets = 100;    // 定义锁对象    private Lock lock = new ReentrantLock();    @Override    public void run() {        while (true) {            try {                // 加锁                lock.lock();                if (tickets > 0) {                    try {                        Thread.sleep(100);                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                    System.out.println(Thread.currentThread().getName()                            + "正在出售第" + (tickets--) + "张票");                }            } finally {                // 释放锁                lock.unlock();            }        }    }}

public class SellTicketDemo {    public static void main(String[] args) {        // 创建资源对象        SellTicket st = new SellTicket();        // 创建三个窗口        Thread t1 = new Thread(st, "窗口1");        Thread t2 = new Thread(st, "窗口2");        Thread t3 = new Thread(st, "窗口3");        // 启动线程        t1.start();        t2.start();        t3.start();    }}

死锁

           01. 同步的弊端：                  A.效率低                  B.容易产生死锁           02. 死锁：两个或者两个以上的线程在争夺资源的过程中发的一种互相等待的现象。

死锁的例子

public class DieLockDemo {    public static void main(String[] args) {        DieLock dl1 = new DieLock(true);        DieLock dl2 = new DieLock(false);        dl1.start();        dl2.start();    }}

public class MyLock {    // 创建两把锁对象    public static final Object objA = new Object();    public static final Object objB = new Object();}

public class DieLock extends Thread {    private boolean flag;    public DieLock(boolean flag) {        this.flag = flag;    }    @Override    public void run() {        if (flag) {            synchronized (MyLock.objA) {                System.out.println("if objA");                synchronized (MyLock.objB) {                    System.out.println("if objB");                }            }        } else {            synchronized (MyLock.objB) {                System.out.println("else objB");                synchronized (MyLock.objA) {                    System.out.println("else objA");                }            }        }    }}

案例分析：
/*
* 分析：
* 资源类：Student
* 设置学生数据:SetThread(生产者)
* 获取学生数据：GetThread(消费者)
* 测试类:StudentDemo
*
* 问题1：按照思路写代码，发现数据每次都是:null—0
* 原因：我们在每个线程中都创建了新的资源,而我们要求的时候设置和获取线程的资源应该是同一个
* 如何实现呢?
* 在外界把这个数据创建出来，通过构造方法传递给其他的类。
*
* 问题2：为了数据的效果好一些，我加入了循环和判断，给出不同的值,这个时候产生了新的问题
* A:同一个数据出现多次
* B:姓名和年龄不匹配
* 原因：
* A:同一个数据出现多次
* CPU的一点点时间片的执行权，就足够你执行很多次。
* B:姓名和年龄不匹配
* 线程运行的随机性
* 线程安全问题：
* A:是否是多线程环境 是
* B:是否有共享数据 是
* C:是否有多条语句操作共享数据 是
* 解决方案：
* 加锁。
* 注意：
* A:不同种类的线程都要加锁。
* B:不同种类的线程加的锁必须是同一把。
*
* 问题3:虽然数据安全了，但是呢，一次一大片不好看，我就想依次的一次一个输出。
* 如何实现呢?
* 通过Java提供的等待唤醒机制解决。
*
* 等待唤醒：
* Object类中提供了三个方法：
* wait():等待
* notify():唤醒单个线程
* notifyAll():唤醒所有线程
* 为什么这些方法不定义在Thread类中呢?
* 这些方法的调用必须通过锁对象调用，而我们刚才使用的锁对象是任意锁对象。
* 所以，这些方法必须定义在Object类中。
*/

public class StudentDemo {    public static void main(String[] args) {        //创建资源        Student s = new Student();        //设置和获取的类        SetThread st = new SetThread(s);        GetThread gt = new GetThread(s);        //线程类        Thread t1 = new Thread(st);        Thread t2 = new Thread(gt);        //启动线程        t1.start();        t2.start();    }}

public class Student {    String name;    int age;    boolean flag; // 默认情况是没有数据，如果是true，说明有数据}

public class SetThread implements Runnable {    private Student s;    private int x = 0;    public SetThread(Student s) {        this.s = s;    }    @Override    public void run() {        while (true) {            synchronized (s) {                //判断有没有                if(s.flag){                    try {                        s.wait(); //t1等着，释放锁                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                }                if (x % 2 == 0) {                    s.name = "林青霞";                    s.age = 27;                } else {                    s.name = "刘意";                    s.age = 30;                }                x++; //x=1                //修改标记                s.flag = true;                //唤醒线程                s.notify(); //唤醒t2,唤醒并不表示你立马可以执行，必须还得抢CPU的执行权。            }            //t1有，或者t2有        }    }}

public class GetThread implements Runnable {    private Student s;    public GetThread(Student s) {        this.s = s;    }    @Override    public void run() {        while (true) {            synchronized (s) {                if(!s.flag){                    try {                        s.wait(); //t2就等待了。立即释放锁。将来醒过来的时候，是从这里醒过来的时候                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                }                System.out.println(s.name + "---" + s.age);                //林青霞---27                //刘意---30                //修改标记                s.flag = false;                //唤醒线程                s.notify(); //唤醒t1            }        }    }}

线程的状态转换及常见执行情况

线程组

 01.线程组概念 线程组： 把多个线程组合到一起。 它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制。  ThreadGroup(String name)创建新的线程组  Thread(ThreadGroup group, Runnable target, String name)将线程加入线程组  public final ThreadGroup getThreadGroup()获取所属线程组  public final String getName()获取线程组名字