多线程

1. 程序、进程与线程

  • 程序:程序是指令和数据的有序集合,其本身没有任何运行的含义,是一个静态的概念。
  • 进程:是执行程序的一次执行过程,是一个动态的概念。是系统资源分配的单位。
  • 线程:在一个进程中可以包含若干个线程,当然一个进程中至少有一个线程,不然没有存在的意义。线程是CPU调度和执行的单位。

2. 核心概念

  • 线程就是独立的执行路径。
  • 在程序运行时,即使没有自己创建线程,后台也会有多个线程,如主线程,gc线程。
  • main()称之为主线程,为系统的入口,用于执行整个程序。
  • 在一个进程中,如果开辟了多个线程,线程的运行由调度器安排调度,调度器时与操作系统密切相关的,先后顺序是不能人为的干预的。
  • 对同一份资源操作时,会存在资源抢夺的问题,需要加入并发控制。
  • 线程会带来额外的开销,如cpu调度时间,并发控制开销。
  • 每个线程在自己的工作内存交互,内存控制不当会造成数据不一致。

3. 线程运行

run(), start()

4. 线程创建的方式

  1. 继承Thread类

    1. start0(),本地方法:Java无权调用,会交给底层的c处理。
  2. 实现Runnable接口(函数式接口,可用lambda表达式)

    new Thread(()->{
    
    }).start();
    
  3. 实现Callable接口(可以有返回值)

5. 静态代理

new Thread(Runnable).start();

6. 线程的状态

  1. 新建
  2. 就绪
  3. 运行
  4. 阻塞
  5. 死亡
img
Image
img
Image

线程状态Thread.State

线程状态。 线程可以处于以下状态之一:

  • NEW 尚未启动的线程处于此状态。
  • RUNNABLE 在Java虚拟机中执行的线程处于此状态。
  • BLOCKED 被阻塞等待监视器锁定的线程处于此状态。
  • WAITING 正在等待另一个线程执行特定动作的线程处于此状态。
  • TIMED_WAITING 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
  • TERMINATED 已退出的线程处于此状态。

线程如为终止状态,则不能再运行,否则报错。

public class Test {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("running");
        });

        System.out.println(thread.getState());

        thread.start();
        System.out.println(thread.getState());

        while (Thread.State.TERMINATED != thread.getState()) {
            Thread.sleep(100);
            System.out.println(thread.getState());
        }

        System.out.println(thread.getState());

    }
}

6.1. 常用的方法

方法 说明
setPriority(int newPriority) 更改线程的优先级
sataic void sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休眠
void join() 等待该线程终止
static void yield() 暂停当前正在执行的线程对象,并执行其他线程
void interrupt() 中断线程,别用这个方式
boolean isAlive() 测试线程是否处于活动状态

6.2. 停止线程

  • 不推荐使用JDK提供的stop()、destory()方法。
  • 推荐线程自己停下来
    • 建议使用一个标志位进行终止变量当flag = flase,则终止线程运行。
public class TestStop implements Runnable{

    // 1.设置一个标识位
    private boolean flag = true;

    @Override
    public void run(){
        int i = 0;
        while(flag){
            System.out.println("run ..... Thread"+i++);
        }
    }

    // 2.设置一个公开的方法停止线程,转换标志位
    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {

        TestStop testStop = new TestStop();
        new Thread(testStop).start();

        for (int i=0;i<1000;i++){
            System.out.println("main"+i);
            if (i==900){
                // 调用 stop方法切换标志位,让线程停止
                testStop.stop();
                System.out.println("线程该停止了!!!");
            }
        }
    }
}

6.3. 线程休眠

  • sleep(时间) 指定当前线程阻塞的毫秒数。
  • sleep存在异常Interrupted Exception。
  • sleep时间达到后线程进入就绪状态。
  • sleep可以模拟网络延时、倒计时等。
  • 每一个对象都有一个锁,sleep不会释放锁。

线程休眠可以放大问题发生的随机性。

public class Test implements Runnable {

    // 票数
    private int ticketNums = 10;

    @Override
    public void run() {
        while (true) {
            if (ticketNums <= 0) {
                break;
            }
            // 模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNums-- + "张票");
        }
    }

    public static void main(String[] args) {
        Test ticket = new Test();
        new Thread(ticket, "小明").start();
        new Thread(ticket, "老师").start();
        new Thread(ticket, "黄牛").start();
    }
}

利用sleep()方法模拟倒计时

public class Test {

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

    private static void timeDown() throws InterruptedException {
        int cnt = 10;
        while (true) {
            System.out.println(cnt--);
            Thread.sleep(1000);
            if (cnt < 0) {
                break;
            }
        }
    }
}

利用sleep方法显示当前时间

public class Test {
    public static void main(String[] args) throws InterruptedException {
        timeCount();
    }

    private static void timeCount() throws InterruptedException {
        int cnt = 10;
        while (cnt >= 0) {
            Date date = new Date(System.currentTimeMillis());
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            System.out.println(simpleDateFormat.format(date));
            cnt--;
            Thread.sleep(1000);
        }
    }
}

6.4. 线程礼让

  • 礼让线程,让当前正在执行的线程暂停,但不阻塞。
  • 将线程从运行状态转为就绪状态。
  • 让cpu重新调度,礼让不一定成功,即礼让的线程有可能会被重新调度。
public class Test {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();

        new Thread(myYield, "A").start();
        new Thread(myYield, "B").start();
    }
}

class MyYield implements Runnable {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "开始执行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName() + "停止执行");
    }
}

6.5. 线程合并(插队join)

  • join合并线程,待此线程执行完成后,再执行其他线程,其他线程阻塞。
  • 可以想象成插队。
public class Test implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("线程vip来了" + i);
        }
    }

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

        //启动我们的线程
        Test testJoin = new Test();
        Thread thread = new Thread(testJoin);
        thread.start();

        //主线程
        for (int i = 0; i < 500; i++) {
            if (i == 200) {
                thread.join();//插队
            }
            System.out.println("main" + i);
        }
    }
}

6.6. 线程优先级

  • Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程,线程调度器按照优先级决定应该调度哪个线程来执行。
  • 线程的优先级用数字表示,范围从1~10。
Modifier and Type Field and Description
static int MAX_PRIORITY线程可以拥有的最大优先级。
static int MIN_PRIORITY线程可以拥有的最小优先级。
static int NORM_PRIORITY分配给线程的默认优先级。
  • 使用以下方式改变或获取优先级
    • getPriority(), setPriority(int newPriority)

优先级的设定应在start()调度之前。

优先级低只是意味着获得调度的概率低,并不是优先级低就不会被调用了。具体由CPU决定。

public class Test {

    public static void main(String[] args) {
        // 主线程默认优先级
        System.out.println(Thread.currentThread().getName() + "--->" + Thread.currentThread().getPriority());

        MyPriority myPriority = new MyPriority();

        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);
        Thread t5 = new Thread(myPriority);
        Thread t6 = new Thread(myPriority);

        // 先设置优先级,再启动
        t1.start();

        t2.setPriority(1);
        t2.start();

        t3.setPriority(4);
        t3.start();

        t4.setPriority(Thread.MAX_PRIORITY);
        t4.start();


        t5.setPriority(8);
        t5.start();

        t6.setPriority(7);
        t6.start();
    }
}

class MyPriority implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "--->" + Thread.currentThread().getPriority());
    }
}

6.7. 守护线程

  • 线程分为用户线程守护线程
  • 虚拟机必须确保用户线程执行完毕。
  • 虚拟机不用等待守护线程执行完毕。
  • 常见的守护线程有:后台记录操作日志、监控内存、垃圾回收等待。
public class Test {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();

        Thread thread = new Thread(god);
        thread.setDaemon(true); // 设置为守护线程
        thread.start();

        new Thread(you).start();

    }
}

class God implements Runnable {

    @Override
    public void run() {
        while (true) {
            System.out.println("God bless you...");
        }
    }
}

class You implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("You passed a day");
        }
    }
}

7. 线程同步【重点】

处理多线程问题时,多个线程访问同一个对象,并且某些线程还想修改这个对象,这时候就需要线程同步。线程同步其实就是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待起那面线程使用完毕,下一个线程再使用。

7.1. 并发

并发:同一个对象被多个线程同时操作。

并发问题

多个线程同时操作一个资源的情况下,线程不安全,数据紊乱。

并发的案例

  1. 购票

下列代码有产生负数,或者多个人抢到同张票的风险。

public class Demo5 implements Runnable {

    int ticketNum = 10;

    @Override
    public void run() {
        while (true) {
            if (ticketNum <= 0) {
                break;
            }
            // 模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "---->拿到了第" + ticketNum-- + "张票");
        }
    }

    public static void main(String[] args) {
        Demo5 demo5 = new Demo5();

        new Thread(demo5, "线程1").start();
        new Thread(demo5, "线程2").start();
        new Thread(demo5, "线程3").start();
    }
}
/*
线程1---->拿到了第10张票
线程2---->拿到了第9张票
线程3---->拿到了第8张票
线程2---->拿到了第7张票
线程1---->拿到了第7张票
线程3---->拿到了第6张票
线程2---->拿到了第5张票
线程1---->拿到了第4张票
线程3---->拿到了第3张票
线程1---->拿到了第1张票
线程3---->拿到了第0张票
线程2---->拿到了第2张票
*/
  1. 取款

可能取款钱数超过账户钱数

public class Test {
    public static void main(String[] args) {

        Account account = new Account("张三", 100);
        new Thread(new Drawing(account, 100), "张三").start();
        new Thread(new Drawing(account, 50), "李四").start();

    }
}

class Account {
    private String name;
    private int money;

    @Override
    public String toString() {
        return "Account{" +
                "name='" + name + '\'' +
                ", money=" + money +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    public Account(String name, int money) {
        this.name = name;
        this.money = money;
    }
}

class Drawing implements Runnable {

    Account account;
    int drawMoney;

    public Drawing(Account account, int drawMoney) {
        this.account = account;
        this.drawMoney = drawMoney;
    }

    @Override
    public void run() {
        if (account.getMoney() - drawMoney < 0) {
            System.out.println(Thread.currentThread().getName() + "余额不足");
            return;
        }
        // 模拟休眠
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        account.setMoney(account.getMoney() - drawMoney);
        System.out.print(Thread.currentThread().getName() + "取出了" + drawMoney + "元 ");
//        System.out.println("当前账户余额" + account.getMoney() + "元");
    }
}
  1. ArrayList是线程不安全的

可能list大小不足10000

public class Test {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}
  • 由于同一进程的多个线程共享同一快存储空间,在带来方便的同时,也带来了访问冲突的问题,为了保证数据在方法中被访问时的正确性,在访问时加入锁机制 synchronized,当一个线程获得对象的排它锁,独占资源,其他线程必须等待,使用后释放锁即可。存在以下问题:
    • 一个线程持有锁会导致其他所有需要此锁的线程被挂起。
    • 在多线程的竞争下,加锁、释放锁会导致比较多的上下文切换调度延时,引起性能问题。
    • 如果一个优先级高的线程等待一个优先级低的线程释放锁,会导致优先级倒置,引起性能问题。

7.2. 线程同步的方法

  1. 前提:队列+锁

  2. synchronized

    1. 同步方法(弊端:锁太多了)(优先级最低)

      • 由于我们可以通过private关键字来保证数据对象只被方法访问,所以我们只要针对方法提出一套机制,这套机制就是synchronized关键字,它包括两种用法:synchronized方法和synchronized块。

        同步方法:public synchronized void method(int args) {}

        方法里面修改的内容才需要锁,锁的太多,浪费资源。

      • synchronized方法控制对“对象”的访问,每个对象对应一把锁。每个synchronized方法都必须获得调用该方法的对象的锁才能执行,否则线程会阻塞,方法一旦执行,就独占该锁,直到方法返回才释放锁,后面被阻塞的线程才能获得这个锁,继续执行。

        缺陷:若将一个大的方法申明为synchronized将会影响效率。

    2. 同步代码块(常用)(优先级次等)

      • 同步块:synchronized(Obj){}
      • Obj称之为同步监视器
        • obj可以是任何对象,但是推荐使用共享资源作为同步监视器。
        • 同步方法中无需指定同步监视器,因为同步方法的同步监视器就是this,就是这个对象本身,或者是class
      • 同步监视器的执行过程
        1. 第一个线程访问,锁定同步监视器,执行其中的代码。
        2. 第二个线程访问,发现同步监视器被锁定,无法访问。
        3. 第一个线程访问完毕,解锁同步监视器。
        4. 第二个线程访问,发现同步监视器没有锁,然后锁定并访问。

      上述三个案例改成线程安全:

      1. 买票

        public class Demo5 implements Runnable {
        
            int ticketNum = 10;
        
            @Override
            public void run() {
                buyTicket();
            }
        
              private synchronized void buyTicket(){
              while (true) {
                    if (ticketNum <= 0) {
                        break;
                    }
                    // 模拟延时
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "---->拿到了第" + ticketNum-- + "张票");
                }
            }
        
            public static void main(String[] args) {
                Demo5 demo5 = new Demo5();
        
                new Thread(demo5, "线程1").start();
                new Thread(demo5, "线程2").start();
                new Thread(demo5, "线程3").start();
            }
        
      2. 取款

        public class Test {
            public static void main(String[] args) {
        
                Account account = new Account("张三", 100);
                new Thread(new Drawing(account, 100), "张三").start();
                new Thread(new Drawing(account, 50), "李四").start();
        
            }
        }
        
        class Account {
            private String name;
            private int money;
        
            @Override
            public String toString() {
                return "Account{" +
                        "name='" + name + '\'' +
                        ", money=" + money +
                        '}';
            }
        
            public String getName() {
                return name;
            }
        
            public void setName(String name) {
                this.name = name;
            }
        
            public int getMoney() {
                return money;
            }
        
            public void setMoney(int money) {
                this.money = money;
            }
        
            public Account(String name, int money) {
                this.name = name;
                this.money = money;
            }
        }
        
        class Drawing implements Runnable {
        
            Account account;
            int drawMoney;
        
            public Drawing(Account account, int drawMoney) {
                this.account = account;
                this.drawMoney = drawMoney;
            }
        
            @Override
            public void run() {
               synchronized(account) {
                  if (account.getMoney() - drawMoney < 0) {
                    System.out.println(Thread.currentThread().getName() + "余额不足");
                    return;
                }
                // 模拟休眠
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                account.setMoney(account.getMoney() - drawMoney);
                System.out.print(Thread.currentThread().getName() + "取出了" + drawMoney + "元 ");
        //        System.out.println("当前账户余额" + account.getMoney() + "元");
               }
            }
        }
        
      3. list集合

        1. 加锁
        public class Test {
            public static void main(String[] args) {
                ArrayList<String> list = new ArrayList<>();
                for (int i = 0; i < 10000; i++) {
                    synchronized(list) {
                      new Thread(()->{
                        list.add(Thread.currentThread().getName());
                    }).start();
                    }
                }
        
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(list.size());
            }
        }
        
        1. 使用JUC下的CopyOnWriteArrayList,线程安全实现类
        public class Test {
            public static void main(String[] args) {
                CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
                for (int i = 0; i < 10000; i++) {
                    new Thread(()->{
                        list.add(Thread.currentThread().getName());
                    }).start();
                }
        
                System.out.println(list.size());
        
            }
        }
        

7.3. 死锁

  • 多个线程个字占有一些共享资源,并且互相等待其他线程占有的资源才能运行,而导致两个或者多个线程都在等待对方释放资源,都停止执行的情形。某一个同步块同时拥有“两个以上对象的锁”时,就可能会发生死锁问题。

  • 条件:

    1. 互斥:一个资源每次只能被一个进程使用。
    2. 请求与保持:一个进程因请求资源而阻塞时,对已获得的资源保持不放。
    3. 不剥夺条件:进程已获得的资源,在未使用完之前,不能强行剥夺。
    4. 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

上面列出了死锁的四个必要条件,只要想办法破其中的一个或多个条件,就可以避免死锁的发生。

死锁的案例

public class Test {
    public static void main(String[] args) {
        MakeUp g1 = new MakeUp(0, "g1");
        MakeUp g2 = new MakeUp(1, "g2");

        new Thread(g1).start();
        new Thread(g2).start();

    }
}

class Lipstick {

}

class Mirror {

}

class MakeUp implements Runnable {
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choose;
    String girlName;

    public MakeUp(int choose, String girlName) {
        this.choose = choose;
        this.girlName = girlName;
    }


    @Override
    public void run() {
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void makeup() throws InterruptedException {
        if (choose == 0) {
            synchronized (lipstick) {
                System.out.println(girlName + "---->" + "Lipstick");
                Thread.sleep(100);
                synchronized (mirror) {
                    System.out.println(girlName + "---->" + "Mirror");
                }
            }
        } else {
            synchronized (mirror) {
                System.out.println(girlName + "---->" + "mirror");
                Thread.sleep(100);
                synchronized (lipstick) {
                    System.out.println(girlName + "---->" + "lipstick");
                }
            }
        }
    }
}

解决方法

private void makeup() throws InterruptedException {
  if (choose == 0) {
    synchronized (lipstick) {
      System.out.println(girlName + "---->" + "Lipstick");
      Thread.sleep(100);
    }
    synchronized (mirror) {
      System.out.println(girlName + "---->" + "Mirror");
    }
  } else {
    synchronized (mirror) {
      System.out.println(girlName + "---->" + "mirror");
      Thread.sleep(100);
    }
    synchronized (lipstick) {
      System.out.println(girlName + "---->" + "lipstick");
    }
  }
}

7.4. Lock (优先级最高)

  • 从JDK5.0开始,Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
  • java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问资源之前应先获得Lock对象。
  • ReentrantLock类实现了Lock,它拥有与synchronized相同的并发性和内存语义,在实现线程安全的控制中,比较常用的是ReentrantLock,可以显式加锁、释放锁。

(ReentrantLock)

  1. lock()
  2. trylock()
  3. unlock()
public class Test {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();
        new Thread(buyTicket).start();
        new Thread(buyTicket).start();
        new Thread(buyTicket).start();
        new Thread(buyTicket).start();
        new Thread(buyTicket).start();

    }
}

class BuyTicket implements Runnable {

    int ticketNum = 10;
    Lock lock = new ReentrantLock();

    @Override
    public void run() {
        try {
            lock.lock();
            buyTicket();
        } finally {
            lock.unlock();
        }

    }

    private void buyTicket() {
        while (ticketNum >= 0) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(ticketNum--);
        }
    }
}

7.5. synchronized与Lock对比

  • Lock是显式锁,(手动开启和关闭锁,别忘记关闭锁)synchronized是隐式锁,出了作用域自动释放。
  • Lock只有代码块锁,synchronized有代码块锁和方法锁。
  • 使用Lock锁,JVM将花费较少的时间来调度线程,性能更好。并且具有更好的扩展性(提供更多的子类)。
  • 优先使用顺序;
    • Lock>同步代码块(已经进入方法体,分配了相应资源)>同步方法(在方法体之外)

8. 线程通信

8.1. 生产者消费者模式

  • 应用场景:生产者和消费者问题
    • 假设仓库中只能存放一件产品,生产者将生产出来的产品放入仓库,消费者将仓库中产品取走消费。
    • 如果仓库中没有产品,则生产者将产品放入仓库,否则停止生产并等待,直到仓库中的产品被消费者取走为止。
    • 如果仓库中放有产品,则消费者可以将产品取走消费,否则停止消费并等待,直到仓库中再次放入产品为止。

这是一个线程同步问题,生产者和消费者共享同一个资源,并且生产者和消费者之间相互依赖,互为条件。

  • 对于生产者,没有生产产品之前,要通知消费者等待,而生产了产品之后,由需要马上通知消费者消费。
  • 对于消费者,在消费之后,要通知生产者已经结束消费,需要生产新的产品以供消费。
  • 在生产者消费者问题中,仅有synchronized是不够的。
    • synchronized可阻止并发更新同一个共享资源,实现了同步。
    • synchronized不能用来实现不同线程之间的消息传递(通信)。
方法名 作用
wait() 表示线程一直等待,直到其他线程通知,与sleep不同,会释放锁。
wait(long timeout) 指定等待的毫秒数。
notify() 唤醒一个处于等待状态的线程
notifyAll() 唤醒同一个对象上所有调用wait()方法的线程,优先级别高的线程优先调度。

注意:均是Object类的方法,都只能在同步方法或者同步代码块中使用,否则会抛出异常IllegalMonitorStateException。

解决方式

  1. 并发协作模型“生产者/消费者模式” --> 管程法

    • 生产者:负责生产数据的模块(可能是方法,对象,线程,进程)。
    • 消费者:负责处理数据的模块(kennel是方法、对象、线程、进程)。
    • 缓冲区:消费者并不能直接使用生产者的数据,他们之间有个“缓冲区”,生产者将生产好的数据放入缓冲区,消费者从缓冲区拿出数据。
    image-20210822001523514
    Image
public class TestPC {
    public static void main(String[] args) {
        Container container = new Container();
        new Producer(container).start();
        new Consumer1(container).start();

    }
}

class Producer extends Thread {
    private Container container;

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


    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            container.push(new Product(i));
            System.out.println("生产了第" + i + "个产品");
        }
    }
}

class Consumer1 extends Thread {
    private Container container;

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

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            Product pop = container.pop();
            System.out.println("消费了第" + pop.getId() + "个产品");
        }
    }
}

class Product {
    int id;

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "Product{" +
                "id=" + id +
                '}';
    }
}

class Container {
    Product[] products = new Product[10];
    int count = -1;

    // 生产
    public synchronized void push(Product product) {
        if (count == products.length - 1) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        products[++count] = product;
        this.notifyAll();
    }

    //消费
    public synchronized Product pop() {
        if (count == -1) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        Product product = products[count--];
        this.notifyAll();
        return product;
    }
}
  1. 并发协作模型“生产者/消费者模式” --> 信号灯法
public class TestPC2 {
    public static void main(String[] args) {
        Product1 product = new Product1();
        new Thread(new Producer1(product)).start();
        new Thread(new Consumer2(product)).start();

    }
}

class Producer1 implements Runnable {
    Product1 product;

    public Producer1(Product1 product) {
        this.product = product;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                System.out.println("生产了" + i + "件产品");
                product.push(i + "");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Consumer2 implements Runnable {
    Product1 product;

    public Consumer2(Product1 product) {
        this.product = product;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                System.out.println("消费了" + product.pop() + "件产品");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

class Product1 {
    boolean needToProduce = true;
    String productName;

    public synchronized void push(String productName) throws InterruptedException {
        if (!needToProduce) {
            this.wait();
        }
        this.notifyAll();
        this.productName = productName;
        needToProduce = !needToProduce;
    }

    public synchronized String pop() throws InterruptedException {
        if (needToProduce) {
            this.wait();
        }
        this.notifyAll();
        needToProduce = !needToProduce;
        return productName;
    }
}

9. 线程池(Pool)

  • 背景:经常创建和销毁、使用量特别大的资源,比如并发情况下的线程,对性能影响很大。
  • 思路:提前创建好多个线程,放入线程池中,使用时直接获取,用完放回池中,可以避免频繁创建销毁,实现重复利用。
  • 好处:
    • 提高响应速度(减少了创建新线程的时间)
    • 降低资源消耗(重复利用线程池中线程,不需要每次都创建)
    • 便于线程管理
      • corePoolSize:核心池大小。
      • maximumPoolSize:最大线程数。
      • keepAliveTime:线程没有任务时最多保持多长时间会终止。
  • JKD5.0起提供了线程池相关API:ExecutorService和Executors
  • ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor
    • void execute(Runnable command):执行任务/命令,没有返回值,一般用来执行Runnable。
    • <T> Future<T> submit(Callable<T> task):执行任务,有返回值,一般用来执行Callable。
    • void shutdown()关闭连接池。
  • Executors:工具类、线程池的工厂类,用于创建并返回不同类型的线程池。
public class Test {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        executorService.execute(new MyThread());
        executorService.execute(new MyThread());
        executorService.execute(new MyThread());
        executorService.execute(new MyThread());
        executorService.execute(new MyThread());
        executorService.shutdown();
    }
}

class MyThread implements Runnable {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
  • ExecutorService的实现类之一ThreadPoolExecutor
Constructor and Description
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue)创建一个新的 ThreadPoolExecutor与给定的初始参数和默认线程工厂和拒绝执行处理程序。
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler)创建一个新的 ThreadPoolExecutor与给定的初始参数和默认线程工厂。
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory)创建一个新的 ThreadPoolExecutor与给定的初始参数和默认拒绝执行处理程序。
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)创建一个新 ThreadPoolExecutor给定的初始参数。
ThreadPoolExecutor executorService = new ThreadPoolExecutor(1, 10, 1000, TimeUnit.MILLISECONDS, new SynchronousQueue<>(), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
  1. 池化技术
  2. 池的大小
  3. 最大连接数
  4. 保持时间
  5. ...
Copyright © rootwhois.cn 2021-2022 all right reserved,powered by GitbookFile Modify: 2022-11-26 20:03:31

results matching ""

    No results matching ""