Java多线程经典案例分享

汇总

- 案例一
- 案例二
- 案例三
- 案例四
- 案例五
- 案例六
- 案例七

案例一

实现一个容器，提供两个方法，add()，count() 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束。
本案例我通过闭锁（也叫门栓锁）实现，实现如下：

package day_12_28.zuoye;

import java.util.ArrayList;

import java.util.List;

import java.util.concurrent.CountDownLatch;

/**

 * @author soberw

 * @Classname AddAndCount

 * @Description 实现一个容器，提供两个方法，add，count 写两个线程，

 * 线程1添加10个元素到容器中，线程2实现监控元素的个数，

 * 当个数到5个时，线程2给出提示并结束。

 * @Date 2021-12-28 10:45

 */

public class AddAndCount {

    CountDownLatch cdl = new CountDownLatch(1);

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

    public static void main(String[] args) {

        var aac = new AddAndCount();

        new Thread(aac::add, "A").start();

        new Thread(aac::count, "B").start();

    }

    void add() {

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

            try {

                Thread.sleep(200);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            String item = String.format("%s - %d", "item", i);

            list.add(item);

            System.out.println(Thread.currentThread().getName() + ":" + item);

            if (i == 4) {

                cdl.countDown();

            }

        }

    }

    void count() {

        try {

            cdl.await();

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        System.out.println("程序结束...");

        System.exit(0);

    }

}

案例二

编写程序模拟死锁。
死锁，简单来说就是两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。
下面我就模拟这一状态：

package day_12_28.zuoye;

/**

 * @author soberw

 * @Classname Deadlock

 * @Description 编写程序模拟死锁

 * @Date 2021-12-28 10:59

 */

public class Deadlock {

    private final Object o1 = new Object();

    private final Object o2 = new Object();

    public static void main(String[] args) {

        Deadlock d = new Deadlock();

        new Thread(d::m1).start();

        new Thread(d::m2).start();

    }

    void m1(){

        System.out.println(Thread.currentThread().getName() + "启动等待...");

        synchronized(o1){

            try {

                Thread.sleep(1000);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            synchronized(o2){

                System.out.println("哈哈..");

            }

        }

    }

    void m2(){

        System.out.println(Thread.currentThread().getName() + "启动等待...");

        synchronized(o2){

            try {

                Thread.sleep(1000);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            synchronized(o1){

                System.out.println("哈哈..");

            }

        }

    }

}

案例三

编写程序，实现三个线程，运行输出 A1 B2 C3 A4 B5 C6 ……
我这里用了两种方式去实现：
方式一：
用公平锁：

package day_12_28.zuoye;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.concurrent.locks.ReentrantLock;

/**

 * @author soberw

 * @Classname TurnNumber

 * @Description 编写程序，实现三个线程，运行输出 A1 B2 C3 A4 B5 C6 …..  用公平锁

 * @Date 2021-12-28 14:09

 */

public class TurnNumber {

    AtomicInteger num = new AtomicInteger(0);

    private final ReentrantLock rl = new ReentrantLock(true);

    public void show() {

        for (; ; ) {

            rl.lock();

            try {

                Thread.sleep(500);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            String tn = Thread.currentThread().getName();

            int i = num.incrementAndGet();

            String s = String.format("%s%d", tn, i);

            System.out.print(s + "  ");

            if ("C".equals(tn)) {

                System.out.println();

            }

            rl.unlock();

        }

    }

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

        TurnNumber tn = new TurnNumber();

        Thread a = new Thread(tn::show, "A");

        Thread b = new Thread(tn::show, "B");

        Thread c = new Thread(tn::show, "C");

        a.setPriority(Thread.MAX_PRIORITY);

        a.start();

        b.setPriority(Thread.NORM_PRIORITY);

        b.start();

        c.setPriority(Thread.MIN_PRIORITY);

        c.start();

    }

}

方式二：
用join() 方法

package day_12_28.zuoye;

import java.util.concurrent.atomic.AtomicInteger;

/**

 * @author soberw

 * @Classname TurnNumber

 * @Description 编写程序，实现三个线程，运行输出 A1 B2 C3 A4 B5 C6 …..  第二种写法，用join()

 * @Date 2021-12-28 14:09

 */

public class TurnNumber2 {

    AtomicInteger num = new AtomicInteger(0);

    public void show() {

        try {

            Thread.sleep(500);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        String tn = Thread.currentThread().getName();

        int i = num.incrementAndGet();

        String s = String.format("%s%d", tn, i);

        System.out.print(s + "  ");

        if ("C".equals(tn)) {

            System.out.println();

        }

    }

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

        TurnNumber2 tn = new TurnNumber2();

        while (true) {

            Thread a = new Thread(tn::show, "A");

            Thread b = new Thread(tn::show, "B");

            Thread c = new Thread(tn::show, "C");

            a.setPriority(Thread.MAX_PRIORITY);

            a.start();

            a.join();

            b.setPriority(Thread.NORM_PRIORITY);

            b.start();

            b.join();

            c.setPriority(Thread.MIN_PRIORITY);

            c.start();

            c.join();

        }

    }

}

案例四

创建五个线程并进入等待状态，等两秒后主线程开始并释放全部线程，最后主线程结束

本案例我用的是wait() 与notifyAll()组合形式;

package day_12_27;

import java.util.concurrent.TimeUnit;

/**

 * @author soberw

 * @Classname WaitAndNotify

 * @Description  创建五个线程并进入等待状态，等两秒后主线程开始并释放全部线程，最后主线程结束

 * @Date 2021-12-27 15:47

 */

public class WaitAndNotify {

    public static void main(String[] args) {

        Object co = new Object();

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

            MyThread t = new MyThread("Thread" + i, co);

            t.start();

        }

        try {

            TimeUnit.SECONDS.sleep(2);

            System.out.println("-----Main Thread notify-----");

            synchronized (co) {

                //co.notify();

                co.notifyAll();

            }

            TimeUnit.SECONDS.sleep(2);

            System.out.println("Main Thread is end.");

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }

    static class MyThread extends Thread {

        private String name;

        private Object co;

        public MyThread(String name, Object o) {

            this.name = name;

            this.co = o;

        }

        @Override

        public void run() {

            System.out.println(name + " is waiting.");

            try {

                synchronized (co) {

                    co.wait();

                }

                System.out.println(name + " has been notified.");

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

}

案例五

用五个线程实现，求123456789 之间放±和100的表达式，如果一个线程求出结果，立即告诉其它停止。

这里我用到了AtomicBoolean原子类来保证数据的原子性：

package day_12_27.zuoye;

import java.util.Random;

import java.util.concurrent.atomic.AtomicBoolean;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

/**

 * @author soberw

 * @Classname Number100

 * @Description 用五个线程实现，求123456789 之间放+-和100的表达式，如果一个线程求出结果，立即告诉其它停止。

 * @Date 2021-12-27 21:14

 */

public class Number100 {

    //原子类，保证原子性

    AtomicBoolean ab = new AtomicBoolean(true);

    public void show() {

        String[] ss = {"", "+", "-"};

        StringBuilder sbu = new StringBuilder();

        sbu.append("1");

        Random random = new Random();

        while (ab.get()) {

            for (int i = 2; i < 9; i++) {

                sbu.append(ss[random.nextInt(3)]);

                sbu.append(i);

            }

            Pattern p = Pattern.compile("[0-9]+|-[0-9]+");

            Matcher m = p.matcher(sbu.toString());

            int sum = 0;

            while (m.find()) {

                sum += Integer.parseInt(m.group());

            }

            if (sum == 100) {

                ab.set(false);

                System.out.println(Thread.currentThread().getName() + ":" + sbu.toString() + " = 100");

            }

            sbu.delete(1, sbu.length());

        }

    }

    public static void main(String[] args) {

        var n = new Number100();

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

            new Thread(n::show).start();

        }

    }

}

案例六

模拟经典问题，生产者-消费者问题：
方式一：

package day_12_28.zuoye;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

/**

 * @author soberw

 * @Classname ProductorAndConsumerForLock

 * @Description   用线程通信机制解决生产者消费者问题

 * @Date 2021-12-28 19:18

 */

public class ProductorAndConsumerForLock {

    public static void main(String[] args) {

        Clerk1 clerk1 = new Clerk1();

        Productor1 pro = new Productor1(clerk1);

        Consumer1 con = new Consumer1(clerk1);

        new Thread(pro, "生产者 A").start();

        new Thread(con, "消费者 B").start();

//		 new Thread(pro, "生产者 C").start();

//		 new Thread(con, "消费者 D").start();

    }

}

class Clerk1 {

    private int product = 0;

    private Lock lock = new ReentrantLock();

    private Condition condition = lock.newCondition();

    // 进货

    public void get() {

        lock.lock();

        try {

            if (product >= 1) { // 为了避免虚假唤醒，应该总是使用在循环中。

                System.out.println("产品已满！");

                try {

                    condition.await();

                } catch (InterruptedException e) {

                }

            }

            System.out.println(Thread.currentThread().getName() + " : "

                    + ++product);

            condition.signalAll();

        } finally {

            lock.unlock();

        }

    }

    // 卖货

    public void sale() {

        lock.lock();

        try {

            if (product <= 0) {

                System.out.println("缺货！");

                try {

                    condition.await();

                } catch (InterruptedException e) {

                }

            }

            System.out.println(Thread.currentThread().getName() + " : "

                    + --product);

            condition.signalAll();

        } finally {

            lock.unlock();

        }

    }

}

// 生产者

class Productor1 implements Runnable {

    private Clerk1 clerk1;

    public Productor1(Clerk1 clerk1) {

        this.clerk1 = clerk1;

    }

    @Override

    public void run() {

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

            try {

                Thread.sleep(200);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            clerk1.get();

        }

    }

}

// 消费者

class Consumer1 implements Runnable {

    private Clerk1 clerk1;

    public Consumer1(Clerk1 clerk1) {

        this.clerk1 = clerk1;

    }

    @Override

    public void run() {

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

            clerk1.sale();

        }

    }

}

方式二：

package day_12_28.zuoye;

/**

 * @author soberw

 * @Classname ProducerAndConsumer

 * @Description 用等待唤醒机制解决生产者消费者问题

 * @Date 2021-12-28 16:25

 */

public class ProductorAndConsumer {

    public static void main(String[] args) {

        Clerk clerk = new Clerk();

        Productor pro = new Productor(clerk);

        Consumer cus = new Consumer(clerk);

        new Thread(pro, "生产者 A").start();

        new Thread(cus, "消费者 B").start();

        new Thread(pro, "生产者 C").start();

        new Thread(cus, "消费者 D").start();

    }

}

//店员

class Clerk {

    private int product = 0;

    //进货

    public synchronized void get() {//循环次数：0

        //为了避免虚假唤醒问题，应该总是使用在循环中

        while (product >= 1) {

            System.out.println("产品已满！");

            try {

                this.wait();

            } catch (InterruptedException e) {

            }

        }

        System.out.println(Thread.currentThread().getName() + " : " + ++product);

        this.notifyAll();

    }

    //卖货

    public synchronized void sale() {//product = 0; 循环次数：0

        while (product <= 0) {

            System.out.println("缺货！");

            try {

                this.wait();

            } catch (InterruptedException e) {

            }

        }

        System.out.println(Thread.currentThread().getName() + " : " + --product);

        this.notifyAll();

    }

}

//生产者

class Productor implements Runnable {

    private Clerk clerk;

    public Productor(Clerk clerk) {

        this.clerk = clerk;

    }

    @Override

    public void run() {

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

            try {

                Thread.sleep(200);

            } catch (InterruptedException e) {

            }

            clerk.get();

        }

    }

}

//消费者

class Consumer implements Runnable {

    private Clerk clerk;

    public Consumer(Clerk clerk) {

        this.clerk = clerk;

    }

    @Override

    public void run() {

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

            clerk.sale();

        }

    }

}

案例七

开十个线程打印输出1~10000中偶数的值，计算总耗时
我采用的是闭锁机制：

package day_12_28.zuoye;

import java.util.concurrent.CountDownLatch;

/**

 * @author soberw

 * @Classname CountTime

 * @Description 开十个线程打印输出1~10000中偶数的值，计算总耗时    用闭锁（门栓）

 * @Date 2021-12-28 15:22

 */

public class CountTime {

    static CountDownLatch cdl = new CountDownLatch(10);

    void show() {

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

            if (i % 2 == 0) {

                System.out.println(Thread.currentThread().getName() + ":" + i);

            }

        }

        cdl.countDown();

    }

    public static void main(String[] args) {

        CountTime ct = new CountTime();

        long start = System.currentTimeMillis();

        try {

            Thread.sleep(100);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

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

            new Thread(ct::show).start();

        }

        try {

            cdl.await();

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        long end = System.currentTimeMillis();

        System.out.println((end - start - 100) + "--------------");

    }

}

巴特西

Java多线程经典案例分享

汇总

案例一

案例二

案例三

案例四

案例五

案例六

案例七

最新文章

热门文章