Java基础学习笔记：第十一章（下）线程与进程

最新推荐文章于 2024-08-01 15:33:26 发布

猛肝自然强

最新推荐文章于 2024-08-01 15:33:26 发布

阅读量110

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/LastYHM/article/details/107522949

版权

java基础专栏收录该内容

20 篇文章 1 订阅

订阅专栏

基于同步机制的延展问题

1 死锁

/*
* 线程的同步机制带来的问题：死锁
* *
1. 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
* *
2. 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
* *
3. 我们在编程程序时，要避免出现死锁！！
* */
public class DeadLockTest {
    public static void main(String[] args) {
        StringBuilder s1 = new StringBuilder();
        StringBuilder s2 = new StringBuilder();
        new Thread() {
            public void run() {
                synchronized (s1) {
                    s1.append("a");
                    s2.append("1");
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s2) {
                        s1.append("b");
                        s2.append("2");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();
        new Thread() {
            public void run() {
                synchronized (s2) {
                    s1.append("c");
                    s2.append("3");
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s1) {
                        s1.append("d");
                        s2.append("4");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();
    }
}

2 解决单例模式中的懒汉式的线程安全问题

/**
 * 解决单例模式中的懒汉式的线程安全问题
 */
public class SingletonTest {
    public static void main(String[] args) {
// Bank.bank = null;
    }
}

class Bank {
    private Bank() {
    }

    private static Bank bank = null;

    //方式一：线程安全的，但是效率不高
// public synchronized static Bank getInstance() {
//
// if (bank == null) {
//
// bank = new Bank();
// }
// return bank;
// }
// public static Bank getInstance() {
// //方式二：线程安全的，比方式一稍好
// synchronized (Bank.class) {
// if (bank == null) {
// bank = new Bank();
// }
// }
// return bank;
// }
//方式三：比方式二效率高
    public static Bank getInstance() {
        if (bank == null) {
            synchronized (Bank.class) {
                if (bank == null) {
                    bank = new Bank();
                }
            }
        }
        return bank;
    }
}

jdk5.0使用Lock锁的方式解决线程安全问题

1. 描述

/
* 
* 除了使用synchronized同步机制处理线程安全问题之外，还可以使用jdk5.0提供的Lock锁的方式
* 
* 一、步骤：
* 1. 创建Lock实现类的对象：ReentrantLock （可重入锁） --->保证多个线程使用同一个Lock对象
* 2. 调用Lock的方法：lock()。调用此方法的线程就可以操作共享数据。其他线程等待
* 3. 在操作共享数据时，可以调用Lock的方法：unlock()。此方法一定要执行！
* 
* 二、面试题：synchronized 和 Lock方式的异同？
* 相同点：解决线程的安全问题的两种不同方式。 synchronized在jdk1.0就有。 Lock在jdk5.0新增
* 不同点：① Lock通过显式的调用unlock()结束对共享数据的操作，更灵活！② 在线程通信中，Lock搭配
Condition使用更灵活。
* 使用建议：参考Lock的api:
* Lock implementations provide more extensive locking
* operations than can be obtained using synchronized methods
* and statements
*/

2. 代码实现

public class WindowTest {
    public static void main(String[] args) {
        Window1 w = new Window1();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

class Window1 implements Runnable {
    private int ticket = 100;
    //1.
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {
//2.
                lock.lock();
                if (ticket > 0) {
                    try {
                        Thread.sleep(30);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "售票，票号为:" +
                            ticket);
                    ticket--;
                } else {
                    break;
                }
            } finally {
//3.
                lock.unlock();
            }
        }
    }
}

面试题：解决Java中线程的安全问题有几种方式？三种：同步代码块、同步方法、Lock锁
面试题：synchronized 和 Lock方式的异同？

线程的通信

1 说明

* 1. 线程通信涉及到三个方法：
* wait():当执行到此方法时，当前的线程就进入阻塞状态，同时释放对同步监视器的调用。需要被唤醒，才可以继续执行。
* notify():当执行到此方法时，就会唤醒被wait的一个线程。如果有多个被wait的线程，则唤醒优先级高的那个
* notifyAll():当执行到此方法时，就会唤醒所有被wait的线程。
* *
* 2. 说明：
* ① wait()、notify()、notifyAll()三个方法必须使用在同步代码块或同步方法中。不能在Lock中使用
* ② wait()、notify()、notifyAll()三个方法的调用者是同步监视器。否则，报
java.lang.IllegalMonitorStateException
* ③ wait()、notify()、notifyAll()三个方法定义在java.lang.Object类中
*

2 例题

例题：使用两个线程打印 1-100。线程1, 线程2 交替打印

public class CommunicationTest {
    public static void main(String[] args) {
        PrintNum p = new PrintNum();
        Thread t1 = new Thread(p, "线程1");
        Thread t2 = new Thread(p, "线程2");
        t1.start();
        t2.start();
    }
}

class PrintNum implements Runnable {
    private int number = 1;
    private Object obj = new Object();

    @Override
    public void run() {
        while (true) {
// synchronized (this) {
            synchronized (obj) {//
                obj.notifyAll();//唤醒被wait的线程
                if (number <= 100) {
                    try {
                        Thread.sleep(20);//在同步结构中，执行此方法不会释放同步监视器
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number++;
//让当前线程进入等待状态
                    try {
                        obj.wait();//在同步结构中，执行此方法会释放同步监视器
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }
}

3 面试题

面试题：sleep()和wait()的异同？
* 相同点：一旦执行，都会使得当前线程结束执行状态，进入等待状态。
* 不同点： ① 定义方法所属的类：sleep():Thread中定义。 wait():Object中定义
* ② 使用范围的不同：sleep()可以在任何需要使用的位置被调用； wait():必须使用在同步代码块或同步方
法中
* ③ 都在同步结构中使用的时候，是否释放同步监视器的操作不同：sleep():不会释放同步监视器 ;wait():
会释放同步监视器
* ④ 结束等待的方式不同：sleep()：指定时间一到就结束阻塞。 wait():需要被唤醒，进而结束阻塞。

4 补充

在这里插入图片描述

5 例题：生产者、消费者问题

/*
* 例题：生产者、消费者问题：
* 生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，
* 店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，
* 如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中
* 有产品了再通知消费者来取走产品。
* *
分析： 线程 操作 资源类
* 1. 是否是一个多线程问题？是！生产者 、消费者
* 2. 是否有线程安全问题呢？有！
* 2. 是否有共享数据？有！产品数量
* 2. 是否需要使用同步机制？是！
* 3. 是否涉及到线程通信？是！
* * */
public class ConsumerProducerTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Producer p1 = new Producer(clerk);
        Consumer c1 = new Consumer(clerk);
        Consumer c2 = new Consumer(clerk);
        p1.setName("生产者1");
        c1.setName("消费者1");
        c2.setName("消费者2");
        p1.start();
        c1.start();
        c2.start();
    }
}

//生产者
class Producer extends Thread {
    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }

    @
            Override
    public void run() {
        System.out.println("=========生产者开始生产产品========");
        while (true) {
            try {
                Thread.sleep(40);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //要求clerk去增加产品
            clerk.addProduct();
        }
    }
}

//消费者
class Consumer extends Thread {
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println("=========消费者开始消费产品========");
        while (true) {
            try {
                Thread.sleep(90);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //要求clerk去减少产品
            clerk.minusProduct();
        }
    }
}

//资源类
class Clerk {
    private int productNum = 0;//产品数量

    //增加产品
    public synchronized void addProduct() {
        if (productNum < 20) {
            productNum++;
            System.out.println(Thread.currentThread().getName() +
                    "生产了第" + productNum + "个产品");
//唤醒消费者
            this.notifyAll();
        } else {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    //减少产品
    public synchronized void minusProduct() {
        if (productNum > 0) {
            System.out.println(Thread.currentThread().getName() +
                    "消费了第" + productNum + "个产品");
            productNum--;
//唤醒生产者
            this.notifyAll();
        } else {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

jdk5.0 新增了两种多线程的创建方式

1 实现Callable接口


//例题：遍历100以内的偶数，并计算所有偶数的和
//1.创建一个实现Callable的实现类
class NumThread implements Callable {
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

public class ThreadNew {
    public static void main(String[] args) {
//3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
//4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
//5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();
//
//
// 接收返回值
        try {//6.获取Callable中call方法的返回值
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2 使用线程池的方式


//创建并使用多线程的第四种方法：使用线程池
//使用线程池创建多线程的好处：
//1.降低了资源的消耗，使用完的线程可以被复用。
//2.提高了程序的响应速度。
//3.便于管理。
class NumberThread implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

class NumberThread1 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

public class ThreadPool {
    public static void main(String[] args) {
//1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
// //设置线程池的属性
// System.out.println(service.getClass());//ThreadPoolExecutor
        service1.setMaximumPoolSize(20);
//2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());//适合适用于Runnable
// service.submit(Callable callable);//适合使用于Callable
//3.关闭连接池
        service.shutdown();
    }
}