Java多线程（二）

线程优先级

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。

优先级高的不一定先执行，大多数情况是这样的。

优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调度了。

优先级的设定建议在start()调度前，setPriority之后紧接start()

守护线程_daemon

• 线程分为用户线程和守护线程
• 虚拟机必须确保用户线程执行完毕
• 虚拟机不用等待守护线程执行完毕
• 例子：后台记录操作日志，监控内存，垃圾回收等待等

thread.setDaemon(true);//默认false表示是用户线程

该thread即使是永远运行，也会结束，因为是守护线程，JVM不会等待，用户线程结束之后即结束。

线程同步

多个线程操作同一个资源。每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。

由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可。存在以下问题：

• 一个线程持有锁会导致其他所有需要此锁的线程挂起
• 在多线程竞争下，加锁、释放锁会导致比较多的上下文切换和调度延时，引起性能问题
• 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题

不安全案例：（ArrayList是线程不安全的）

public static void main(String[] args) {

    List<String> list = new ArrayList<>();

    for (int i = 0; i < 1000; i++) {

        new Thread(()->{

           list.add(Thread.currentThread().getName());

        }).start();

    }

    System.out.println(list.size());

}

可能的原因：1.可能有些线程还在执行时，就输出了size() 2.某个瞬间，往list同一位置添加了两次覆盖了

同步方法及同步块

同步方法： synchronized默认锁的是this这个对象本身（后续反射章节会有涉及）

public synchronized void method(int args){}

同步块：synchronized(obj){}

举例一个不安全银行取钱的例子：

public class TestAccount {

    public static void main(String[] args) throws InterruptedException {

        Account account = new Account("sum",100);

        Drawing you = new Drawing(account,50,"you");

        Drawing girlfriend = new Drawing(account,70,"girl");

        new Thread(you).start();

        new Thread(girlfriend).start();

    }

}

class Account{

    String name;

    int Money;

    public Account(String name,int money){

        this.Money=money;

        this.name=name;

    }

}

class Drawing implements Runnable{

    Account account;

    int drawingMoney;

    int nowMoney=0;

    String name;

    public Drawing(Account account,int drawingMoney, String name) {

        this.account = account;

        this.drawingMoney = drawingMoney;

        this.name = name;

    }

    @Override

    public void run() {

        if(account.Money-drawingMoney < 0){

            System.out.println("there's no money");

        }

        try {

            Thread.sleep(1000);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        account.Money = account.Money - drawingMoney;

        nowMoney = nowMoney+drawingMoney;

        System.out.println("bank remains "+account.Money);

        System.out.println(name+" get "+nowMoney);

    }

}

结果如下：

银行没有判断出钱不够，这里的sleep放大了事故可能性。

增加同步块：

@Override

public void run() {

    synchronized (account){

        if(account.Money-drawingMoney < 0){

            System.out.println("there's no money");

            return ;

        }

        try {

            Thread.sleep(1000);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        account.Money = account.Money - drawingMoney;

        nowMoney = nowMoney+drawingMoney;

        System.out.println(name+" get "+nowMoney);

        System.out.println("bank remains "+account.Money);

    }

}

共同操作的是account所以obj即为它，同步块里即为原来的方法块，可以锁任何对象（需要锁操作的共同资源对象），这是和synchronized方法不同之处。

用该方法改进上方的不安全ArrayList

public static void main(String[] args) throws InterruptedException {

    List<String> list = new ArrayList<>();

    for (int i = 0; i < 1000; i++) {

        new Thread(()->{

           synchronized (list){

               list.add(Thread.currentThread().getName());

           }

        }).start();

    }

    Thread.sleep(1000);

    System.out.println(list.size());

}

输出即为1000。

提一下并发编程中的安全List（CopyOnWriteArrayList）

public static void main(String[] args) throws InterruptedException {

    CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList();

    for (int i = 0; i < 10000; i++) {

        new Thread(()->{

           list.add(Thread.currentThread().getName());

        }).start();

    }

    Thread.sleep(5000);

    System.out.println(list.size());

}

这里的List是线程安全的。

死锁

多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源释放才能运行。某个同步块同时拥有“两个以上对象的锁”时，就可能发生死锁。

补充：synchronized(obj){}其实可以理解为等待obj释放锁之后执行代码块

产生死锁的四个必要条件：

• 互斥条件：一个资源每次只能被一个进程使用
• 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
• 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
• 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系（例：A等B拿的资源，B等A拿的资源）

Lock锁

JDK5.0开始，提供了更强大的线程同步机制，通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。

java.util.concurrent.locks.lock接口是控制多个线程对共享资源进行访问的工具。ReentrantLock是Lock的常用实现类（可重入锁）。

class TestLock2 implements Runnable{

    int ticketNums = 10;

    private final ReentrantLock lock = new ReentrantLock();

    @Override

    public void run() {

        while(true){

            try {

                lock.lock();//加锁

                if(ticketNums>0){

                    try {

                        Thread.sleep(1000);

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                    System.out.println(ticketNums--);

                }else{

                    break;

                }

            } finally {    //解锁

                lock.unlock();

            }

        }

    }

}

仍然是抢票举例，.lock()加锁，.unlock()解锁，以上结果没有冲突情况。

线程协作（生产者消费者问题）

在这个问题中，仅用synchronized是不够的

• synchronized可阻止并发更新同一个共享资源，实现了同步
• synchronized不能用来实现不同线程之间的通信

解决方式1：管程法

public class TestPC {   //利用缓冲区解决

    public static void main(String[] args) {

        Buffer buffer = new Buffer();

        new Producer(buffer).start();

        new Consumer(buffer).start();

    }

}

class Producer extends Thread{

    Buffer buffer;

    public Producer(Buffer buffer){

        this.buffer = buffer;

    }

    @Override

    public void run() {

        for (int i = 1; i < 100; i++) {

            try {

                Thread.sleep(100);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            buffer.push(new product(i));

            System.out.println("生产了第"+i+"个产品");

        }

    }

}

class Consumer extends Thread{

    Buffer buffer;

    public Consumer(Buffer buffer){

        this.buffer = buffer;

    }

    @Override

    public void run() {

        for (int i = 0; i < 100; i++) {

            try {

                Thread.sleep(200);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            System.out.println("消费了第"+buffer.pop().id+"个产品");

        }

    }

}

class product{

    int id;

    public product(int id) {

        this.id = id;

    }

}

class Buffer{

    product[] pro = new product[10];  //缓存区大小

    int count=0;

    public synchronized void push(product p){

        if(count == pro.length){

            //通知等待消费

            try {

                this.wait();

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

        pro[count] = p;

        count++;

        //通知可以消费了

        this.notifyAll();

    }

    public synchronized product pop() {

        if (count == 0) {

            //等待生产

            try {

                this.wait();

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

        count--;

        product p2 = pro[count];

        this.notifyAll();

        return p2;

    }

}

此段代码只涉及了新的wait()和notifyAll()，其余过程和操作系统相关知识描述一致，可以理一下思路。

解决方式2：信号灯法（利用标志位）建立一个(true,false)标志位进行判断，操作系统相关知识已有，不再详细描述

线程池

背景：经常创建和销毁，使用量特别大

思路：提前创建好多个线程，放在线程池中，使用时直接获取，使用完放回池中，可以避免频繁创建销毁，实现重复利用。

好处：

• 提高响应速度（减少了创建新线程的时间）
• 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
• 便于线程管理

corePoolSize：核心池大小

maximumPoolSize：最大线程数

keepAliveTime：线程没有任务时最多保持多长时间后会终止

简单举例：

public class TestPool {

    public static void main(String[] args) {

        //创建服务，创建线程池

        ExecutorService service = Executors.newFixedThreadPool(10);

        //执行

        service.execute(new MyThread());

        service.execute(new MyThread());

        service.execute(new MyThread());

        service.execute(new MyThread());

        //关闭链接

        service.shutdown();

    }

}

class MyThread implements Runnable{

    @Override

    public void run() {

        System.out.println(Thread.currentThread().getName());

    }

}

线程池相关知识将在并发编程部分详细介绍。