11多线程

1.多线程介绍

进程：进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。

线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

创建线程

java中提供了两种创建线程的方法：

一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。创建对象，开启线程。run方法相当于其他线程的main方法。
另一种方法是声明一个实现 Runnable 接口的类。该类然后实现 run 方法。然后创建Runnable的子类对象，传入到某个线程的构造方法中，开启线程。

1.1通过扩展Thread类进行创建线程

package cn.jxufe.java.chapter10.demo01;

/*
 * 创建和启动一个线程
 *   创建Thread子类对象
 *   子类对象调用方法start()
 *      让线程程序执行,JVM调用线程中的run
 */
public class Test01Thread {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        SubThread st = new SubThread();
        st.start();
        for (int i = 0; i < 50; i++) {
            System.out.println("main..." + i);
        }
    }

}

/*
 *  定义子类,继承Thread 
 *  重写方法run 
 */
class SubThread extends Thread {
    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println("sub..." + i);
        }
    }
}

思考：线程对象调用 run方法和调用start方法区别？

线程对象调用run方法不开启线程。仅是对象调用方法。线程对象调用start开启线程，并让jvm调用run方法在开启的线程中执行。

1.1.1 获取线程名称

package cn.jxufe.java.chapter10.demo01;

/*
 *  每个线程,都有自己的名字
 *  运行方法main线程,名字就是"main"
 *  其他新键的线程也有名字,默认 "Thread-0","Thread-1"
 *  
 *  JVM开启主线程,运行方法main,主线程也是线程,是线程必然就是
 *  Thread类对象
 *  Thread类中,静态方法
 *   static Thread currentThread()返回正在执行的线程对象
 */
public class Test02Thread {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        NameThread nt = new NameThread();
        nt.setName("旺财");
        nt.start();

        /*Thread t =Thread.currentThread();
        System.out.println(t.getName());*/
        System.out.println(Thread.currentThread().getName());
    }

}

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

1.1.2sleep 方法

package cn.jxufe.java.chapter10.demo01;

public class Test03Sleep {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        /*for(int i = 0 ; i < 5 ;i++){
        Thread.sleep(50);
        System.out.println(i);
        }*/

        new SleepThread().start();
    }

}

class SleepThread extends Thread {
    public void run() {
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(1000);
            } catch (Exception ex) {

            }
            System.out.println(i);
        }
    }
}

1.1.3示例

package cn.jxufe.java.chapter10.demo01;

public class Test04ThreadDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ThreadExample te1 = new ThreadExample("线程1");
        ThreadExample te2 = new ThreadExample("线程2");
        ThreadExample te3 = new ThreadExample("线程3");
        te1.start();
        te2.start();
        te3.start();
    }

}
class ThreadExample extends Thread{
    public ThreadExample(String s) {
        // TODO Auto-generated constructor stub
        setName(s);
    }
    
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("第" +i+"次调用" +getName());
        }
    }
}

1.2通过实现Runnable接口创建线程

创建线程的另一种方法是声明实现 Runnable 接口的类。该类然后实现 run 方法。然后创建Runnable的子类对象，传入到某个线程的构造方法中，开启线程。

为何要实现Runnable接口，Runable是啥玩意呢？继续API搜索。

查看Runnable接口说明文档：Runnable接口用来指定每个线程要执行的任务。包含了一个 run 的无参数抽象方法，需要由接口实现类重写该方法。

package cn.jxufe.java.chapter10.demo02;

public class Test01ThreadWithRunnable {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        SubRunnable sr = new SubRunnable();
        Thread t = new Thread(sr);
        t.start();
        for (int i = 0; i < 50; i++) {
            System.out.println("main..." + i);
        }
    }

}

class SubRunnable implements Runnable {
    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println("run..." + i);
        }
    }
}

为什么需要定一个类去实现Runnable接口呢？继承Thread类和实现Runnable接口有啥区别呢？

实现Runnable接口，避免了继承Thread类的单继承局限性。覆盖Runnable接口中的run方法，将线程任务代码定义到run方法中。

创建Thread类的对象，只有创建Thread类的对象才可以创建线程。线程任务已被封装到Runnable接口的run方法中，而这个run方法所属于Runnable接口的子类对象，所以将这个子类对象作为参数传递给Thread的构造函数，这样，线程对象创建时就可以明确要运行的线程的任务。

1.2.1实现Runnable的好处

第二种方式实现Runnable接口避免了单继承的局限性，所以较为常用。实现Runnable接口的方式，更加的符合面向对象，线程分为两部分，一部分线程对象，一部分线程任务。继承Thread类，线程对象和线程任务耦合在一起。一旦创建Thread类的子类对象，既是线程对象，有又有线程任务。实现runnable接口，将线程任务单独分离出来封装成对象，类型就是Runnable接口类型。Runnable接口对线程对象和线程任务进行解耦。

1.2.2示例

package cn.jxufe.java.chapter10.demo02;

public class Test02RunnableDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ThreadExample te = new ThreadExample();
        Thread t1 = new Thread(te);
        Thread t2 = new Thread(te);
        t1.setName("小明");
        t2.setName("小红");
        t1.start();
        t2.start();
    }

}

class ThreadExample implements Runnable {
    private static int numApple = 1;

    @Override
    public void run() {
        // TODO Auto-generated method stub
        while (true) {
            if (numApple < 11) {
                System.out.println(Thread.currentThread().getName() + "捡到一个苹果，" + "现在有" + numApple++ + "个苹果");
            }
            else {
                break;
            }
        }
    }
}

1.3两种创建线程方式的联系与区别

package cn.jxufe.java.chapter10.demo03;
public class Test01ThreadWithThread {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyThread mt1 = new MyThread();
        MyThread mt2 = new MyThread();
        MyThread mt3 = new MyThread();
        mt1.start();
        mt2.start();
        mt3.start();
    }

}

class MyThread extends Thread {
    private int ticket = 6;

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 20; i++) {
            if (ticket > 0)
                System.out.println(this.getName() + "卖票：还剩下" + ticket-- + "张票");
        }
    }
}

package cn.jxufe.java.chapter10.demo03;

public class Test02ThreadWithRunnable {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyThread2 mt = new MyThread2();
        Thread th1 = new Thread(mt);
        Thread th2 = new Thread(mt);
        Thread th3 = new Thread(mt);
        th1.start();
        th2.start();
        th3.start();
    }

}

class MyThread2 implements Runnable {
    private int ticket = 6;
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 20; i++) {
            if (ticket > 0)
                System.out.println(Thread.currentThread().getName() + "卖票：还剩下" + ticket-- + "张票");
        }
    }
}

1.4匿名内部类创建线程

package cn.jxufe.java.chapter10.demo02;

/*
 *  使用匿名内部类,实现多线程程序
 *  前提: 继承或者接口实现
 *  new 父类或者接口(){
 *     重写抽象方法
 *  }
 */
public class Test02ThreadWithAnonymousClass {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 继承方式 XXX extends Thread{ public void run(){}}
        new Thread() {
            public void run() {
                System.out.println("!!!");
            }
        }.start();

        // 实现接口方式 XXX implements Runnable{ public void run(){}}

        Runnable r = new Runnable() {
            public void run() {
                System.out.println("###");
            }
        };
        new Thread(r).start();

        new Thread(new Runnable() {
            public void run() {
                System.out.println("@@@");
            }
        }).start();
    }

}

2.线程状态

一般来说有四种原因进入就绪状态：

1.start方法

2.阻塞事件解除，重新进入就绪状态。

3.调用yield方法

4.jvm本身将本地线程切换到其他线程

一般来说有四种原因进入阻塞状态：

1.sleep方法

2.wait方法

3.jion方法

4.一些io操作，read、wait

3.线程方法

3.1线程停止

3.2sleep方法

3.3yield方法

3.4join方法

3.5线程优先级

3.6守护线程

3.7常用的其他方法

4.线程池

线程池，其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。

我们详细的解释一下为什么要使用线程池？

在java中，如果每个请求到达就创建一个新线程，开销是相当大的。在实际使用中，创建和销毁线程花费的时间和消耗的系统资源都相当大，甚至可能要比在处理实际的用户请求的时间和资源要多的多。除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。如果在一个jvm里创建太多的线程，可能会使系统由于过度消耗内存或“切换过度”而导致系统资源不足。为了防止资源不足，需要采取一些办法来限制任何给定时刻处理的请求数目，尽可能减少创建和销毁线程的次数，特别是一些资源耗费比较大的线程的创建和销毁，尽量利用已有对象来进行服务。

线程池主要用来解决线程生命周期开销问题和资源不足问题。通过对多个任务重复使用线程，线程创建的开销就被分摊到了多个任务上了，而且由于在请求到达时线程已经存在，所以消除了线程创建所带来的延迟。这样，就可以立即为请求服务，使用应用程序响应更快。另外，通过适当的调整线程中的线程数目可以防止出现资源不足的情况。

4.1使用线程池方式--Runnable接口

package cn.jxufe.java.chapter10.demo02;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/*
 *  JDK1.5新特性,实现线程池程序
 *  使用工厂类 Executors中的静态方法创建线程对象,指定线程的个数
 *   static ExecutorService newFixedThreadPool(int 个数) 返回线程池对象
 *   返回的是ExecutorService接口的实现类 (线程池对象)
 *   
 *   接口实现类对象,调用方法submit (Ruunable r) 提交线程执行任务
 *          
 */
public class Test03ThreadPool {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //调用工厂类的静态方法,创建线程池对象
                //返回线程池对象,是返回的接口
        ExecutorService es = Executors.newFixedThreadPool(2);
        //调用接口实现类对象es中的方法submit提交线程任务
        //将Runnable接口实现类对象,传递
        es.submit(new ThreadPoolRunnable());
        es.submit(new ThreadPoolRunnable());
        es.submit(new ThreadPoolRunnable());
    }

}
class ThreadPoolRunnable implements Runnable {
    public void run(){
        System.out.println(Thread.currentThread().getName()+" 线程提交任务");
    }
}

4.2 使用线程池方式—Callable接口

Callable接口：与Runnable接口功能相似，用来指定线程的任务。其中的call()方法，用来返回线程任务执行完毕后的结果，call方法可抛出异常。
ExecutorService：线程池类

　　n <T> Future<T> submit(Callable<T> task)：获取线程池中的某一个线程对象，并执行线程中的call()方法

Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用

　　使用线程池中线程对象的步骤：

创建线程池对象
创建Callable接口子类对象
提交Callable接口子类对象
关闭线程池

package cn.jxufe.java.chapter10.demo02;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/*
 *  实现线程程序的第三个方式,实现Callable接口方式
 *  实现步骤
 *    工厂类 Executors静态方法newFixedThreadPool方法,创建线程池对象
 *    线程池对象ExecutorService接口实现类,调用方法submit提交线程任务
 *    submit(Callable c)
 */
public class Test05ThreadPoolCallable {

    public static void main(String[] args) throws Exception, ExecutionException {
        // TODO Auto-generated method stub
        ExecutorService es = Executors.newFixedThreadPool(2);
        // 提交线程任务的方法submit方法返回 Future接口的实现类
        Future<String> f = es.submit(new ThreadCallable());
        System.out.println(f.get());
//        es.execute(new ThreadCallable());//将报错
    }

}

class ThreadCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        // TODO Auto-generated method stub
        return "abc";
    }
}

5.示例，多线程求和

package cn.jxufe.java.chapter10.demo03;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/*
 * 使用多线程技术,求和
 * 两个线程,1个线程计算1+100,另一个线程计算1+200的和
 * 多线程的异步计算
 */
public class Test03GetSumWithThread {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        // TODO Auto-generated method stub
        ExecutorService es = Executors.newFixedThreadPool(2);
        Future<Integer> f1 = es.submit(new MyThread3(100));
        Future<Integer> f2 = es.submit(new MyThread3(200));
        System.out.println(f1.get());
        System.out.println(f2.get());
    }

}

class MyThread3 implements Callable<Integer> {
    private int a;

    public MyThread3(int a) {
        // TODO Auto-generated constructor stub
        this.a = a;
    }

    @Override
    public Integer call() throws Exception {
        // TODO Auto-generated method stub
        int sum = 0;
        for (int i = 1; i <= a; i++) {
            sum += i;
        }
        return sum;
    }
}

6.线程安全

package cn.jxufe.java.chapter10.demo04;

public class Test01ThreadSafty {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Ticket mt = new Ticket();
        Thread th1 = new Thread(mt);
        Thread th2 = new Thread(mt);
        Thread th3 = new Thread(mt);
        th1.start();
        th2.start();
        th3.start();
        
    }

}

class Ticket implements Runnable {
    private int ticket = 10;

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 20; i++) {
            if (ticket > 0)
                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            System.out.println(Thread.currentThread().getName() + "卖票：还剩下" + ticket-- + "张票");
        }
    }
}

不使用sleep将不会出现负数

其实，线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。

7.线程同步

java中提供了线程同步机制，它能够解决上述的线程安全问题。

线程同步的方式有两种：

方式1：同步代码块
方式2：同步方法

7.1同步代码块

同步代码块: 在代码块声明上加上synchronized

synchronized (锁对象) {

可能会产生线程安全问题的代码

}

同步代码块中的锁对象可以是任意的对象；但多个线程时，要使用同一个锁对象才能够保证线程安全。

package cn.jxufe.java.chapter10.demo04;

public class Test01ThreadSafty {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Ticket mt = new Ticket();
        Thread th1 = new Thread(mt);
        Thread th2 = new Thread(mt);
        Thread th3 = new Thread(mt);
        th1.start();
        th2.start();
        th3.start();

    }

}

/*
 *  通过线程休眠,出现安全问题
 *  解决安全问题,Java程序,提供技术,同步技术
 *  公式:
 *    synchronized(任意对象){
 *      线程要操作的共享数据
 *    }
 *    同步代码块
 */
class Ticket implements Runnable {
    private int ticket = 10;
    private Object obj = new Object();

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 20; i++) {
            synchronized (obj) { // 此处不能为匿名对象，要同一把锁
                if (ticket > 0) {
                    try {
                        Thread.sleep(20);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "卖票：还剩下" + ticket-- + "张票");
                }
            }
        }
    }
}

package 多线程;

import java.util.ArrayList;
import java.util.List;

public class T01电影院订票 {

    public static void main(String[] args) {
        List<Integer> available = new ArrayList<>();
        available.add(1);
        available.add(2);
        available.add(3);
        available.add(4);
//        available.add(5);
        available.add(6);
        available.add(7);

        List<Integer> seats1 = new ArrayList<>();
        seats1.add(1);
        seats1.add(2);
        List<Integer> seats2 = new ArrayList<>();
        seats2.add(4);
        seats2.add(5);
        seats2.add(6);

        Cinema cinema = new Cinema(available, "wanda");
        new Thread(new Customer(cinema, seats1), "张三").start();
        new Thread(new Customer(cinema, seats2), "李四").start();

    }

}

class Customer implements Runnable {
    Cinema cinema;
    List<Integer> seats;

    public Customer(Cinema cinema, List<Integer> seats) {
        this.cinema = cinema;
        this.seats = seats;
    }

    @Override
    public void run() {
        synchronized (cinema) {
            boolean flag = cinema.bookTickets(seats);
            if (flag) {
                System.out.println("出票成功" + Thread.currentThread().getName() + "->位置为" + seats);
            } else {
                System.out.println("出票失败" + Thread.currentThread().getName() + "->位置不够");

            }
        }
    }
}

class Cinema {
    List<Integer> available;//可用的位置
    String name;//名字

    public Cinema(List<Integer> available, String name) {
        this.available = available;
        this.name = name;
    }

    //购票
    public boolean bookTickets(List<Integer> seats) {
        System.out.println("欢迎光临" + Thread.currentThread().getName() + "可用位置为：" + available);
        List<Integer> copy = new ArrayList<Integer>();
        copy.addAll(available);
        copy.removeAll(seats);
        if (available.size() - copy.size() != seats.size())
            return false;
        //
        available = copy;
        return true;
    }

}

7.2同步方法

同步方法：在方法声明上加上synchronized

public synchronized void method(){

可能会产生线程安全问题的代码

}

同步方法中的锁对象是 this

package cn.jxufe.java.chapter10.demo05;


public class Test01ThreadSafty {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Ticket mt = new Ticket();
        Thread th1 = new Thread(mt);
        Thread th2 = new Thread(mt);
        Thread th3 = new Thread(mt);
        th1.start();
        th2.start();
        th3.start();

    }

}

/*
 *  采用同步方法形式,解决线程的安全问题
 *  好处: 代码简洁
 *  将线程共享数据,和同步,抽取到一个方法中
 *  在方法的声明上,加入同步关键字
 *  
 *  问题:
 *    同步方法有锁吗,肯定有,同步方法中的对象锁,是本类对象引用 this
 *    如果方法是静态的呢,同步有锁吗,绝对不是this
 *    锁是本类自己.class 属性
 *    静态方法,同步锁,是本类类名.class属性
 */
class Ticket implements Runnable {
    private int ticket = 10;

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 20; i++) {
            payTicket();
        }
    }

    public synchronized void payTicket() {
        if (ticket > 0) {
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "卖票：还剩下" + ticket-- + "张票");
        }
    }
}

package cn.jxufe.java.chapter10.demo05;


public class Test01ThreadSafty {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Ticket mt = new Ticket();
        Thread th1 = new Thread(mt);
        Thread th2 = new Thread(mt);
        Thread th3 = new Thread(mt);
        th1.start();
        th2.start();
        th3.start();

    }

}

/*
 *  采用同步方法形式,解决线程的安全问题
 *  好处: 代码简洁
 *  将线程共享数据,和同步,抽取到一个方法中
 *  在方法的声明上,加入同步关键字
 *  
 *  问题:
 *    同步方法有锁吗,肯定有,同步方法中的对象锁,是本类对象引用 this
 *    如果方法是静态的呢,同步有锁吗,绝对不是this
 *    锁是本类自己.class 属性
 *    静态方法,同步锁,是本类类名.class属性
 */
class Ticket implements Runnable {
    private static int ticket = 10;

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 20; i++) {
            payTicket();
        }
    }

    public static synchronized void payTicket() {
        if (ticket > 0) {
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "卖票：还剩下" + ticket-- + "张票");
        }
    }
}

8.Lock接口

查阅API，查阅Lock接口描述，Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。

Lock提供了一个更加面对对象的锁，在该锁中提供了更多的操作锁的功能。

我们使用Lock接口，以及其中的lock()方法和unlock()方法替代同步，对电影院卖票案例中Ticket类进行如下代码修改：

package cn.jxufe.java.chapter10.demo06;

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

public class Test01ThreadSafty {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Ticket mt = new Ticket();
        Thread th1 = new Thread(mt);
        Thread th2 = new Thread(mt);
        Thread th3 = new Thread(mt);
        th1.start();
        th2.start();
        th3.start();

    }

}

/*
 *  使用JDK1.5 的接口Lock,替换同步代码块,实现线程的安全性
 *  Lock接口方法:
 *     lock() 获取锁
 *     unlock()释放锁
 *  实现类ReentrantLock
 */
class Ticket implements Runnable {
    private static int ticket = 10;
    //在类的成员位置,创建Lock接口的实现类对象
    private Lock l = new ReentrantLock();
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 20; i++) {
            //调用Lock接口方法lock获取锁
            l.lock();
            if (ticket > 0) {
                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "卖票：还剩下" + ticket-- + "张票");
            }
            //释放锁,调用Lock接口方法unlock
            l.unlock();
        }
    }

}

放在finally里，官方推荐

package cn.jxufe.java.chapter10.demo06;

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

public class Test01ThreadSafty {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Ticket mt = new Ticket();
        Thread th1 = new Thread(mt);
        Thread th2 = new Thread(mt);
        Thread th3 = new Thread(mt);
        th1.start();
        th2.start();
        th3.start();

    }

}

/*
 *  使用JDK1.5 的接口Lock,替换同步代码块,实现线程的安全性
 *  Lock接口方法:
 *     lock() 获取锁
 *     unlock()释放锁
 *  实现类ReentrantLock
 */
class Ticket implements Runnable {
    private static int ticket = 10;
    // 在类的成员位置,创建Lock接口的实现类对象
    private Lock l = new ReentrantLock();

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 20; i++) {
            // 调用Lock接口方法lock获取锁
            l.lock();
            if (ticket > 0) {
                try {
                    Thread.sleep(20);
                    System.out.println(Thread.currentThread().getName() + "卖票：还剩下" + ticket-- + "张票");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } finally {
                    // 释放锁,调用Lock接口方法unlock
                    l.unlock();
                }

            }

        }
    }

}

9.死锁

同步锁使用的弊端：当线程任务中出现了多个同步(多个锁)时，如果同步中嵌套了其他的同步。这时容易引发一种现象：程序出现无限等待，这种现象我们称为死锁。这种情况能避免就避免掉。

synchronized(A锁){
    synchronized(B锁){
 
    }
}

package cn.jxufe.java.chapter10.demo06;

public class Test02DeadLock {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        DeadLock dl = new DeadLock();
        Thread thread0 = new Thread(dl);
        Thread thread1 = new Thread(dl);
        thread0.start();
        thread1.start();
    }

}

class DeadLock implements Runnable {
    private int i = 0;

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int a = 0; a < 30; a++) {
            if (i % 2 == 0) {
                // 先进入A同步,再进入B同步
                synchronized (LockA.lockA) {
                    System.out.println("lockA");
                    synchronized (LockB.lockB) {
                        System.out.println("lockB");
                    }
                }
            } else {
                // 先进入B同步,再进入A同步
                synchronized (LockB.lockB) {
                    System.out.println("lockB");
                    synchronized (LockA.lockA) {
                        System.out.println("lockA");

                    }
                }
            }
            i++;
        }
    }
}

class LockA {

    public static final LockA lockA = new LockA();
}

class LockB {
    public static final LockB lockB = new LockB();
}

10.等待唤醒机制

线程之间的通信：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。通过一定的手段使各个线程能有效的利用资源。而这种手段即—— 等待唤醒机制。

等待唤醒机制所涉及到的方法：

wait（） :等待，将正在执行的线程释放其执行资格和执行权，并存储到线程池中。
notify（）：唤醒，唤醒线程池中被wait（）的线程，一次唤醒一个，而且是任意的。
notifyAll（）：唤醒全部：可以将线程池中的所有wait() 线程都唤醒。

其实，所谓唤醒的意思就是让线程池中的线程具备执行资格。必须注意的是，这些方法都是在同步中才有效。同时这些方法在使用时必须标明所属锁，这样才可以明确出这些方法操作的到底是哪个锁上的线程。

仔细查看JavaAPI之后，发现这些方法并不定义在 Thread中，也没定义在Runnable接口中，却被定义在了Object类中，为什么这些操作线程的方法定义在Object类中？

因为这些方法在使用时，必须要标明所属的锁，而锁又可以是任意对象。能被任意对象调用的方法一定定义在Object类中。

package cn.jxufe.java.chapter10.demo06;

public class Test03ThreadWait {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Resource r = new Resource();

        Input in = new Input(r);
        Output out = new Output(r);

        Thread tin = new Thread(in);
        Thread tout = new Thread(out);

        tin.start();
        tout.start();
    }

}

/*
 *  定义资源类,有2个成员变量
 *  name,sex
 *  同时有2个线程,对资源中的变量操作
 *  1个对name,age赋值
 *  2个对name,age做变量的输出打印
 */
class Resource {
    public String name;
    public String sex;
    public boolean flag = false;
}

/*
 *  输入的线程,对资源对象Resource中成员变量赋值
 *  一次赋值 张三,男
 *  下一次赋值 lisi,nv
 */
class Input implements Runnable {
    private Resource r;

    public Input(Resource r) {
        this.r = r;
    }

    public void run() {
        int i = 0;
        for (int j = 0; j < 30; j++) {
            synchronized (r) {
                // 标记是true,等待
                if (r.flag) {
                    try {
                        r.wait();
                    } catch (Exception ex) {
                    }
                }

                if (i % 2 == 0) {
                    r.name = "张三";
                    r.sex = "男";
                } else {
                    r.name = "lisi";
                    r.sex = "nv";
                }
                // 将对方线程唤醒,标记改为true
                r.flag = true;
                r.notify();
            }
            i++;
        }

    }

}

/*
 *  输出线程,对资源对象Resource中成员变量,输出值
 */
class Output implements Runnable {
    private Resource r;

    public Output(Resource r) {
        this.r = r;
    }

    public void run() {
        while (true) {
            synchronized (r) {
                // 判断标记,是false,等待
                if (!r.flag) {
                    try {
                        r.wait();
                    } catch (Exception ex) {
                    }
                }
                System.out.println(r.name + ".." + r.sex);
                // 标记改成false,唤醒对方线程
                r.flag = false;
                r.notify();
            }
        }
    }

}

11.生产者消费者模型

package 多线程;

/**
 * 管程法
 */
public class T02生产者消费者模型 {

    public static void main(String[] args) {
        Container container = new Container();
        new Productor(container).start();
        new Consumer(container).start();
    }

}

//生产者
class Productor extends Thread {
    Container container;

    public Productor(Container container) {
        this.container = container;
    }

    @Override
    public void run() {
        //生产
        for (int i = 0; i < 10; i++) {
            System.out.println("生产第" + i + "个馒头");
            container.push(new Steamedbun(i));
        }
    }
}

//消费者
class Consumer extends Thread {
    Container container;

    public Consumer(Container container) {
        this.container = container;
    }

    @Override
    public void run() {
        //消费
        for (int i = 0; i < 10; i++) {
            System.out.println("消费第" + container.pop().id + "个馒头");
        }
    }
}

//缓冲区
class Container {
    Steamedbun[] buns = new Steamedbun[5];//存储容器
    int count = 0;//计数器

    //存储
    public synchronized void push(Steamedbun bun) {
        //何时不能生产  容器没有空间
        if (count == buns.length) {
            try {
                this.wait();//线程阻塞   生产者通知生产 解除阻塞
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        buns[count] = bun;
        count++;
        this.notifyAll();//存在数据了，通知可以消费了
    }

    //获取
    public synchronized Steamedbun pop() {
        //没有数据 只有等待
        if (count == 0) {
            try {
                this.wait();//线程阻塞   生产者通知消费解除阻塞
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果有数据 可以消费
        Steamedbun bun = buns[--count];
        this.notifyAll();//存在空间了，可以唤醒对方生产了
        return bun;
    }

}

//馒头
class Steamedbun {
    int id;

    public Steamedbun(int id) {
        this.id = id;
    }

}

12.定时调度

package 多线程;

/**
 * Volatile用于保证数据的同步，也就是可见性
 */
public class T04Volatile {
    private volatile static int num = 0;

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            while (num == 0) {

            }
        }).start();
        Thread.sleep(1000);
        num = 1;
    }