Java高级--线程（二）

1、线程死锁

当A线程拥有锁资源a时，这是A线程需要锁资源b，而B线程拥有锁资源b，这是B线程需要锁资源a，这样会导致A等待B线程释放资源b，B线程等待A线程释放锁资源a。从而两个线程处于永久等待，导致死锁。

例子：张三和李四两个人要画画，但是只有一只画笔和一张画纸，两者都拥有之后才可以画画。

/*两个锁对象*/
public class LockObject {
    /*代表画笔*/
    public static Object a = new Object();
    /*代表画纸*/
    public static Object b = new Object();
}


public class Zhangsan extends Thread{
    @Override
    public void run() {
        synchronized (LockObject.a){
            System.out.println(Thread.currentThread().getName()+"获取画笔");
            synchronized (LockObject.b){
                System.out.println(Thread.currentThread().getName()+"获取画纸");
                System.out.println("可以画画了");
            }
        }
    }
}


public class Lisi extends Thread{
    @Override
    public void run() {
        synchronized (LockObject.b){
            System.out.println(Thread.currentThread().getName()+"获取画纸");
            synchronized (LockObject.a){
                System.out.println(Thread.currentThread().getName()+"获取画笔");
                System.out.println("可以画画了");
            }
        }
    }
}


public class TestDeadLock {
    public static void main(String[] args) {
        Zhangsan zhangsan = new Zhangsan();
        Lisi lisi = new Lisi();
        zhangsan.setName("张三");
        lisi.setName("李四");
        zhangsan.start();
        lisi.start();
    }
}

上述情况就会产生张三获取画笔，等待画纸，而李四获取画纸，等待画笔，从而两个线程死锁。

操作死锁的原因：

锁与锁之间的嵌套导致。

如何解决死锁：

1、尽量减少锁的嵌套，也就是避免一个线程同时获取多个锁，

2、避免一个线程在锁内同时占用多个资源，尽量保证每个锁只占用一个资源，

3、可以使用一些安全类，

4、可以使用Lock中的枷锁，设置枷锁时间，使用lock.tryLock来代替使用内置锁

2、线程通信

多个线程并发执行时, 在默认情况下CPU是随机切换线程的,当我们需要多个线程来共同完成一件任务, 并且我们希望他们有规律的执行, 那么多线程之间就需要进行线程通信。

等待：

public final void wait();

public final coid wait(long timeout);

必须在对obj加锁的同步代码块中，在一个线程中，调用obj.wait()时，此线程会释放其拥有的所有锁标记，同时将该线程阻塞在obj的等待队列中，释放锁，进入等待队列中。

通知：

public final void notify();

public final void notifyAll();

唤醒等待队列中的线程，进入就绪队列，参与CPU的竞争。

例子，存钱取钱的例子

public class BankCard {
    private double balance;
    //false为卡中没有钱，true为卡中有钱
    private boolean flag=false;

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
    //存钱，如果卡中有钱，不能存
    public synchronized void save(double money) {
        //如果卡中有钱，该线程等待，进入等待队列
        if (flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //卡中没有钱，向卡中存钱
        this.balance = this.balance+money;
        System.out.println(Thread.currentThread().getName()+"向卡中存了"+money+"钱，余额为："+this.balance);
        //设置卡中是否有钱的状态
        this.flag=true;
        //唤醒等待队列中的线程
        this.notify();
    }

    //取钱，卡中没有钱不能取
    public synchronized void take(double money){
        //如果卡中没有钱，该线程等待，进入等待队列
        if (!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //卡中有钱，从卡中取钱
        this.balance = this.balance-money;
        System.out.println(Thread.currentThread().getName()+"从卡中取了"+money+"钱，余额为："+this.balance);
        //设置卡中是否有钱的状态
        this.flag=false;
        //唤醒等待队列中的线程
        this.notify();
    }
}


public class BoySave extends Thread{
    BankCard bankCard;

    public BoySave(BankCard bankCard) {
        this.bankCard = bankCard;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            bankCard.save(1000);
        }
    }
}

public class GirlTake extends Thread{
    BankCard bankCard;

    public GirlTake(BankCard bankCard) {
        this.bankCard = bankCard;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            bankCard.take(1000);
        }
    }
}


public class TestIPC {
    public static void main(String[] args) {
        BankCard bankCard = new BankCard();
        BoySave boySave = new BoySave(bankCard);
        boySave.setName("张三");
        GirlTake girlTake = new GirlTake(bankCard);
        girlTake.setName("李四");
        boySave.start();
        girlTake.start();
    }
}

sleep和wait的区别？

1、类的不同：sleep()属于Thread类，wait()属于Object类；

2、使用位置不同：sleep可以使用在任何代码块，wait只能在加锁的同步代码块中；

3、释放锁：sleep()不释放锁资源，wait()会释放锁资源；

4、用法不同：sleep()时间到了会自动恢复，wait()可以使用notify()或者notityAll()直接唤醒。

notify()和notifyAll()的区别？

notifyAll()会唤醒所有的线程，notify()唤醒一个线程。notifyAll()调用之后，会将全部线程由等待池移到锁池，然后参与锁的竞争，竞争成功则继续执行，如果不成功则留在锁池中等待锁被释放后再次参与竞争。而notify()只会唤醒一个线程，具体唤醒哪一个线程由虚拟机控制。

3、线程池

什么是线程池？

该池子中预先存储若干个线程对象，整个池子就是线程池。

线程是宝贵的内存资源，单个线程约占1MB的空间，过多的分配容易造成内存溢出。频繁的创建及销毁线程会增加虚拟机回收频率，资源开销，造成程序性能下降。

线程池的作用：

1、线程容器，可设定线程分配的数量上限。避免了内存溢出的问题。

2、将预先创建的线程对象存入池中，并重用线程池中的线程对象。

3、避免频繁的创建和销毁

（1）通过工具类Executors创建线程池

所有的线程池封装了一个接口  java.util.concurrent.Executor

他的实现接口：ExecutorService

有一个工具类  Executors可以帮助我们创建相应的线程池

Executor:线程池的根类，里面有一个方法execute()执行Runnable类型的任务,

ExecutorService:线程池的子接口

shutdown():关闭线程池，需要等待线程池中的任务执行完毕后才会关闭

shutdownNow():立即关闭线程池

isTerminated():判断线程池是否终止了

submit():提交任务给线程池中的线程对象，Runable和Callable类型的任务

①创建单一线程池：newSingleThreadExecutor();

②创建定长线程池：newFixedThreadPool(2);

③创建边长线程池：newCachedThreadPool();

④创建延迟线程池：newScheduledThreadPool(10);

/*Executor:线程池的根类，里面有一个方法execute()执行Runnable类型的任务,
ExecutorService:线程池的子接口
shutdown():关闭线程池，需要等待线程池中的任务执行完毕后才会关闭
shutdownNow():立即关闭线程池
isTerminated():判断线程池是否终止了
submit():提交任务给线程池中的线程对象，Runable和Callable类型的任务
*/
public class TestPool {
    public static void main(String[] args) {
        // 创建单一线程池
        //ExecutorService executorService = Executors.newSingleThreadExecutor();
        //创建定长的线程池
        //ExecutorService executorService = Executors.newFixedThreadPool(2);
        //创建可变长的线程池
        //ExecutorService executorService = Executors.newCachedThreadPool();
        /*for (int i = 0; i < 10; i++) {
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"==============");
                }
            });
        }*/
        //创建延迟线程池
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(10);

        for (int i = 0; i < 10; i++) {
            executorService.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"==============");
                }
            },10, TimeUnit.MILLISECONDS);
        }
        executorService.shutdown();
    }
}

（2）使用ThreadPoolExecutor创建线程池（常用）

public class TestPoolIm {
    public static void main(String[] args) {
        //int corePoolSize, 核心线程数
        //int maximumPoolSize,  最大线程数
        //long keepAliveTime,   空闲时间
        //TimeUnit unit,  时间单位
        //BlockingQueue<Runnable> workQueue  阻塞队列
        BlockingQueue blockingQueue = new LinkedBlockingDeque(3);
        //根据自己的业务和服务器配置来配置
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3,5,10, TimeUnit.SECONDS,blockingQueue);
        for (int i = 0; i < 9; i++) {
            threadPoolExecutor.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"------------");
                }
            });
        }
        threadPoolExecutor.shutdown();
    }
}

（3）实现Callable接口创建线程池

public class TestPoolCallable {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //应用场景：适合大文件上传
        Sum1 sum1 = new Sum1();
        //也可以封装到FutureTask类中，不推荐
        /*FutureTask futureTask = new FutureTask(sum1);
        Thread thread = new Thread(futureTask);
        thread.start();
        System.out.println(futureTask.get());*/

        Sum2 sum2 = new Sum2();
        //使用线程池来接收具有返回值的任务
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        Future<Integer> future = executorService.submit(sum1);
        Future<Integer> future2 = executorService.submit(sum2);
        //需要等线程执行完毕后，才会把结果返回给变量
        Integer result = future.get();
        Integer result2 = future2.get();
        System.out.println(result+result2);
    }
}
class Sum1 implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 50; i++) {
            sum+=i;
        }
        return sum;
    }
}

class Sum2 implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 50; i <= 100; i++) {
            sum+=i;
        }
        return sum;
    }
}

Callable和Runable的区别？

1、最大的区别，runnable没有返回值，而实现callable接口的任务线程能返回执行结果

2、callable接口实现类中的run方法允许异常向上抛出，可以在内部处理，try catch，但是runnable接口实现类中run方法的异常必须在内部处理，不能抛出；

Runable和Thread的区别？

1、Runnable的实现方式是实现其接口即可

2、Thread的实现方式是继承其类

3、Runnable接口支持多继承，但基本上用不到

4、Thread实现了Runnable接口并进行了扩展，而Thread和Runnable的实质是实现的关系，不是同类东西，所以Runnable或Thread本身没有可比性。

4、手动锁

Lock是手动锁的父接口，有很多实现类

lock();手动上锁；

tryLock();返回布尔类型，判断是否获得锁资源；

unlock();释放锁资源，放在finally中；

public class TestLock {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        new Thread(ticket,"窗口A").start();
        new Thread(ticket,"窗口B").start();
    }
}
class Ticket extends Thread{
    private Integer ticket=100;
    Lock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true){
            try {
                //手动加锁
                lock.lock();
                if (ticket>0){
                    Thread.sleep(10);
                    ticket = ticket-1;
                    System.out.println(Thread.currentThread().getName()+"卖了一张，剩余："+ticket+"张");
                }else {
                    break;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                //释放锁资源
                lock.unlock();
            }
        }
    }
}

public class TestTryLock {
    public static void main(String[] args) {
        Ticket1 ticket1 = new Ticket1();
        Thread thread1 = new Thread(ticket1,"窗口A");
        Thread thread2 = new Thread(ticket1,"窗口B");
        Thread thread3 = new Thread(ticket1,"窗口C");
        Thread thread4 = new Thread(ticket1,"窗口D");
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }
}
class Ticket1 implements Runnable{
    private int ticket = 100;
    Lock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true){
            try {
                //判断是否获取锁资源
                boolean tryLock = lock.tryLock();
                if (tryLock){
                    if (ticket>0){
                        Thread.sleep(30);
                        ticket = ticket-1;
                        System.out.println(Thread.currentThread().getName()+"卖了一张，剩余："+ticket+"张");
                    }else {
                        break;
                    }
                }else {
                    System.out.println("未获取锁资源");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
}

synchronized和lock的区别？

1、synchronized可以给类，方法，代码块加锁，而lock只能给代码块加锁；

2、synchronized不需要手动获取锁资源和释放锁资源，使用简单，发生异常会自动释放锁，不会造成死锁；而lock需要自己加锁和释放锁，如果使用不当没有unlock()去释放锁资源就会造成死锁。

3、通过lock()可以知道有没有成功获取锁资源（tryLock），而synchronized不能。

5、线程安全问题

①为线程加锁。synchronized和lock锁。

②使用线程安全类。StringBuffer，Hashtable，ConcurrentHashMap（jdk1.7之后加入）都是线程安全类。

6、线程的状态

New（新建状态）——>调用start方法——>就绪状态——>获取CPU——>执行状态——>调用sleep|join进入等待状态——>终止状态

阻塞状态——>未获取锁资源