Java学习笔记1

笔记1

---

Java多线程

1.生产者消费者问题
2.死锁的产生以及解决办法

一：生产者消费者问题

实际上，准确说应该是“生产者-消费者-仓储”模型，离开了仓储，
生产者消费者模型就显得没有说服力了。对于此模型，应该明确一下几点：

1. 生产者仅仅在仓储未满时候生产，仓满则停止生产。
2. 消费者仅仅在仓储有产品时候才能消费，仓空则等待。
3. 当消费者发现仓储没产品可消费时候会通知生产者生产。
4. 生产者在生产出可消费产品时候，应该通知等待的消费者去消费。

生产者类：

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

public class Producer extends Thread {
    private List<Integer> list = new ArrayList<>();

    public Producer(List<Integer> list) {
        this.list = list;
    }

    @Override
    public synchronized void run() {
        // TODO Auto-generated method stub
        int i = 0;
        while (true) {
            while (list.size() == 5) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            list.add(i);
            System.out.println("加入" + i);
            i++;
        }
    }
}

消费者类：

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

public class Consumer extends Thread {
    private List<Integer> list = new ArrayList<>();

    public Consumer(List<Integer> list) {
        this.list = list;
    }

    @Override
    public synchronized void run() {
        // TODO Auto-generated method stub
        while (true) {
            while (list.size() == 0) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            int x = list.remove(list.size() - 1);
            System.out.println("消费了" + x);
        }
    }
}

测试类：

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

public class Demo {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        new Producer(list).start();
        new Consumer(list).start();
    }
}

二.死锁

1.简单描述：

进程A占有资源R1，等待进程B占有的资源Rr；进程B占有资源Rr，等待进程A占有行，若不采取其它措施，这种循环等待状况的资源R1。而且资源R1和Rr只允许一个进程占用，即：不允许两个进程同时占用。结果，两个进程都不能继续执会无限期持续下去，就发生了进程死锁。（在Java中主要存在线程死锁）

2.产生死锁的必要条件

从以上分析可见，如果在计算机系统中同时具备下面四个必要条件时，那麽会发生死锁。换句话说，只要下面四个条件有一个不具备，系统就不会出现死锁。

〈1〉临界资源使用的互斥性条件。即某个资源在一段时间内只能由一个进程占有，不能同时被两个或两个以上的进程占有。这种独占资源如CD-ROM驱动器，打印机等等，必须在占有该资源的进程主动释放它之后，其它进程才能占有该资源。这是由资源本身的属性所决定的。如独木桥就是一种独占资源，两方的人不能同时过桥。

〈2〉资源的不可抢占性条件。进程所获得的资源在未使用完毕之前，资源申请者不能强行地从资源占有者手中夺取资源，而只能由该资源的占有者进程自行释放。如过独木桥的人不能强迫对方后退，也不能非法地将对方推下桥，必须是桥上的人自己过桥后空出桥面（即主动释放占有资源），对方的人才能过桥。

〈3〉部分申请资源，占有且申请条件。进程至少已经占有一个资源，但又申请新的资源；由于该资源已被另外进程占有，此时该进程阻塞；但是，它在等待新资源之时，仍继续占用已占有的资源。还以过独木桥为例，甲乙两人在桥上相遇。甲走过一段桥面（即占有了一些资源），还需要走其余的桥面（申请新的资源），但那部分桥面被乙占有（乙走过一段桥面）。甲过不去，前进不能，又不后退；乙也处于同样的状况。

〈4〉循环等待条件。存在一个进程等待序列{P1，P2，…，Pn}，其中P1等待P2所占有的某一资源，P2等待P3所占有的某一源，……，而Pn等待P1所占有的的某一资源，形成一个进程循环等待环。就像前面的过独木桥问题，甲等待乙占有的桥面，而乙又等待甲占有的桥面，从而彼此循环等待。

下面是一个死锁类：

public class Deadlock {
    public static void main(String[] args) {
        // 首先定义两个临界资源
        final Object resource1 = "resource1";
        final Object resource2 = "resource2";

        Thread t1 = new Thread() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                synchronized (resource1) {
                    System.out.println(Thread.currentThread().getName() + "lock" + resource1);
                    try {
                        sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    synchronized (resource2) {
                        System.out.println(Thread.currentThread().getName() + "lock" + resource2);
                    }
                }
            }
        };

        Thread t2 = new Thread() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                synchronized (resource2) {
                    System.out.println(Thread.currentThread().getName() + "lock" + resource2);
                    try {
                        sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    synchronized (resource1) {
                        System.out.println(Thread.currentThread().getName() + "lock" + resource1);
                    }
                }
            }
        };
        t1.start();
        t2.start();
    }
}