简述Java多线程(二)

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接口是控制多个线程对共享资源进行访问的工具。ReentrantLockLock的常用实现类(可重入锁)。

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(),其余过程和操作系统相关知识描述一致,可以理一下思路。
wait(), notify()notifyAll()三个方法必须使用在同步代码块或同步方法中。这三个方法的调用者必须是同步代码块或同步方法中的同步监视器,否则会出现IllegalMonitorStateException异常。

解决方式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());
    }
}

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

posted @ 2021-04-13 03:29  GaoYuan206  阅读(66)  评论(0编辑  收藏  举报