Day19 Thread2（线程安全、Lock接口、守护线程、线程池）

最新推荐文章于 2024-07-12 15:51:39 发布
最新推荐文章于 2024-07-12 15:51:39 发布
阅读量117 收藏
点赞数
文章标签： java 多线程 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43986982/article/details/111058746
版权

1、线程安全

为什么会出现线程安全问题？

  • 需求：A线程将“Hello”存入数组；B线程将“World”存入数组。
  • 线程不安全：
    • 当多线程并发访问临界资源时，如果破坏原子操作，可能会造成数据不一致。
    • 临界资源：共享资源（同一对象），一次仅允许一个线程使用，才可保证其正确性。
    • 原子操作：不可分割的多步操作，被视作一个整体，其顺序和步骤不可打乱或缺省。
1.1 解决线程安全问题-同步锁

同步锁的关键词是synchronized。
有两种方式
1.同步代码块：在同一个时间里只允许一条线程进入同步代码块，当代码块运行完毕后，其他线程才会被CPU调度，必须保证监视器为同一个对象。

语法：

synchronized(临界资源对象){ //对临界资源对象加锁
//代码（原子操作）
}

注意：

package Day19_thread2.safe;/*
        车站售票
        解决线程安全的问题：
            1.同步锁：synchronized，是一个关键词来的
                1.1同步代码块：
                    在同一个时间里只允许一条线程进入同步代码块，当代码块运行完毕后，其他线程
                    才会被CPU调度，必须保证监视器为同一个对象
                1.2同步方法：
                    被synchronized修饰的方法为同步方法，同一时间只允许一条线程调用，当同步方法
                    执行完后，其他线程才会被CPU调度，监视器为方法本身。要求保证调用同一个方法，
                    可以使用静态方法或者保证对象为同一个。
 */

public class Demo01 {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            Thread thread = new Thread(new Task("窗口"+i));
            thread.start();
            //new Thread(new Task("窗口00"+i)).start();
        }
    }
}
class Task implements Runnable{
    private static int ticket = 1000;
    private static final Object obj = new Object();//静态属性的Object()
    private String name;
    public Task(String name){
        this.name = name;
    }

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

    private void safe() throws InterruptedException {
        while (true){//死循环
            Thread.sleep(1);
            synchronized (obj){
                if (ticket > 0){
                    System.out.println(name+"正在售票"+ticket--);
                }else {
                    System.out.println(name+"售票结束！！");
                    break;
                }
            }
        }
    }
}

2.同步方法：被synchronized修饰的方法为同步方法，同一时间只允许一条线程调用，当同步方法执行完后，其他线程才会被CPU调度，监视器为方法本身。要求保证调用同一个方法，可以使用静态方法或者保证对象为同一个。

语法：
synchronized 返回值类型 方法名称(形参列表){ //对当前对象（this）加锁
// 代码（原子操作）
}

注意：

package Day19_thread2.safe;/*
    使用同步方法，每一个线程实现的都不是同一个方法，方法为静态方法
    同步方法：被synchronized修饰的方法为同步方法，同一时间只允许一条线程调用，当同步方法执行完后，其他线程
    才会被CPU调度，监视器为方法本身。要求保证调用同一个方法，可以使用静态方法或者保证对象为同一个。
 */

public class Demo02 {
    public static void main(String[] args) {
        for (int i = 1; i < 11; i++) {
            new Thread(new Task2(),"窗口"+i).start();
        }
    }
}
class Task2 implements Runnable {
    private static int ticket = 1000;
    private static final Object obj = new Object();//静态属性的Object()
    private boolean flag = true;

    @Override
    public void run() {
        try {
            while (flag) {
                Thread.sleep(1);
                flag = safe();//定义了全局变量flag，需要赋值给safe(),不然程序会一直运行下去。
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private synchronized static boolean safe() throws InterruptedException {
        if (ticket > 0) {
            //Thread.currentThread().getName()获取程序名
            System.out.println(Thread.currentThread().getName() + "正在售票" + ticket--);
        } else {
            System.out.println(Thread.currentThread().getName() + "售票结束！！");
            return false;
        }
        return true;
    }
}

案例：同步方法的应用

package Day19_thread2.safe;
//同步方法,对象为同一个
public class Demo03 {
    public static void main(String[] args) {
        //任务类对象只有一个
        Task3 task3 = new Task3();
        for (int i = 1; i < 11; i++) {
            //Thread(Thread构造方法，线程名)
            new Thread(task3,"窗口"+i).start();
        }
    }
}
class Task3 implements Runnable{
    private static int ticket = 1000;
    private boolean flag = true;
    @Override
    public void run() {
        try {
            while (flag){
                Thread.sleep(1);
                flag = safe();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //同步方法 --非静态
    private synchronized boolean safe(){
        if (ticket > 0){
            System.out.println(Thread.currentThread().getName()+"正在出售"+ticket--);
        }else {
            System.out.println(Thread.currentThread().getName()+"售票结束！！");
            return false;
        }
        return true;
    }
}
1.2线程通信方法
方法说明
public final void wait()释放锁，进入等待队列
public final void wait(long timeout)在超过指定的时间前，释放锁，进入等待队列
public final void notify()随机唤醒、通知一个线程
public final void notifyAll()唤醒、通知所有线程

注意：所有的等待、通知方法必须在对加锁的同步代码块中。

wait()特点：

  • 1、会使线程进入阻塞状态；
  • 2、必须在synchronized中使用，没有则会出现IllegalMonitorStateException异常；
  • 当线程调用wait()进入阻塞状态的时候，资源会被释放；
  • 当线程调用wait()进入阻塞状态后，没有通过notify()或者notifyAll()唤醒线程，线程就会进入死锁状态。
package Day19_thread2.safe;
public class Demo05 {
    public static final Object obj = new Object();
    public static void main(String[] args) throws InterruptedException {
/*      //第一种方法
        new Thread(new Task5()).start();
        Thread.sleep(1000);
        new Thread(new Task5()).start();
        Thread.sleep(1000);
        new Thread(new Task6()).start();*/
        //会陷入阻塞状态
        new Task5().start();
        Thread.sleep(1000);
        //会陷入阻塞状态
        new Task5().start();
        Thread.sleep(1000);
        //唤醒陷入阻塞状态的线程
        new Task6().start();
    }
}
class Task5 extends Thread{
    //private static Object obj =new Object();
    @Override
    public void run() {
        /*try {
            //在synchronized外面使用wait()
            Demo05.obj.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }*/
        synchronized (Demo05.obj){
            System.out.println(Thread.currentThread().getName()+"线程开始");
            try {
                //会释放资源
                Demo05.obj.wait(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"线程结束！");
        }
    }
}
class Task6 extends Thread{
    //private static Object obj =new Object();
    @Override
    public void run() {
        synchronized (Demo05.obj){
            System.out.println(Thread.currentThread().getName()+"线程开始");
            //通过notify()唤醒进入阻塞状态的线程
            //通过notifyAll()唤醒所有进入阻塞状态的线程
            Demo05.obj.notifyAll();
            System.out.println(Thread.currentThread().getName()+"线程结束！");
        }
    }
}

2、Lock接口

2.1 Lock
  • JDK5加入，与synchronized比较，显示定义，结构更灵活。
  • 提供更多实用性方法，功能更强大、性能更优越。

常用方法：

方法名描述
void lock()获取锁，如锁被占用，则等待。
boolean tryLock()尝试获取锁（成功返回true。失败返回false，不阻塞）。
void unlock()释放锁。
package Day19_thread2.lock;
//Lock:互斥对象锁或者排它锁，与同步锁最大的区别是需要显示获取和释放锁，不容易出现死锁。
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Demo01 {
    public static void main(String[] args) {
        for (int i = 1; i < 11; i++) {
            new Thread(new Task("窗口"+i)).start();
        }
    }
}
class Task implements Runnable{
    private static int ticket = 1000;
    private static String name;
    private static Lock lock = new ReentrantLock();
    public Task(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        try {
            safe();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    private void safe() throws InterruptedException {
        while (true){
            Thread.sleep(1);
            //获取锁
            lock.lock();
            try {
                //wait()只能在synchronized中使用
                //lock.wait();
                if (ticket > 0){
                    System.out.println(Thread.currentThread().getName()+"正在出售"+ticket--);
                }else {
                    System.out.println(Thread.currentThread().getName()+"售票结束！！");
                    break;
                }
            }finally{
                //释放锁（关闭）
                lock.unlock();
            }
        }
    }
}

3、守护线程

在Java中有两类线程：User Thread(用户线程)、Daemon Thread(守护线程)

用个比较通俗的比如，任何一个守护线程都是整个JVM中所有非守护线程的保姆。

只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。Daemon的作用是为其他线程的运行提供便利服务，守护线程最典型的应用就是GC(垃圾回收器)，它就是一个很称职的守护者。

User和Daemon两者几乎没有区别，唯一的不同之处就在于虚拟机的离开：如果 User Thread已经全部退出运行了，只剩下Daemon Thread存在了，虚拟机也就退出了。 因为没有了被守护者，Daemon也就没有工作可做了，也就没有继续运行程序的必要了。

package Day19_thread2.daemon;/*
 * @author  pyh
 * @date  2020/12/10 0010 下午 5:40
 * @version 1.0
 * @since JDK1.8_241
        守护线程:当一条线程被设置为守护线程时，其他线程执行完，守护线程则销毁
                 守护线程守护所有的线程
                 垃圾回收机制（GC）也是一条守护线程
 */

public class Demo01 {
    public static void main(String[] args) throws InterruptedException {
        MyThread1 myThread1 = new MyThread1();
        myThread1.setDaemon(true);
        myThread1.start();
        new MyThread2().start();
        for (int i = 0; i < 150; i++) {
            Thread.sleep(1);
            System.out.println("主线程:"+i);
        }
    }
}
class MyThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 300; i++) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("守护线程:"+i);
        }
    }
}
class MyThread2 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程:"+i);
        }
    }
}

案例：

package Day19_thread2.daemon;/*
 * @author  pyh
 * @date  2020/12/10 0010 下午 5:55
 * @version 1.0
 * @since JDK1.8_241
 *      在B线程中设置A为守护线程
 *      到底是B线程结束，A线程跟着结束
 *      还是所有线程结束，A线程结束
 */

public class Demo02 {
    public static void main(String[] args) {
        //A线程的对象
        MyThread3 myThread3 = new MyThread3();
        //B线程
        new MyThread4(myThread3).start();
        //C线程
        new MyThread5().start();
    }
}
//A线程
class MyThread3 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 400; i++) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("守护A子线程:"+i);
        }
    }
}
//B线程
class MyThread4 extends Thread{
    private Thread thread;
    //通过构造方法接收A线程的对象
    public MyThread4(Thread thread){
        this.thread = thread;
    }
    @Override
    public void run() {
        //设置A线程为守护线程
        thread.setDaemon(true);
        thread.start();
        for (int i = 0; i < 200; i++) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("B子线程:"+i);
        }
    }
}
class MyThread5 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 300; i++) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("C子线程:"+i);
        }
    }
}

4、线程池

线程池：节省了线程的创建和销毁

Executor：线程池的顶级接口。

ExecutorService：线程池接口，可通过submit(Runnable task) 提交任务代码。

Executors工厂类：通过此类可以获得一个线程池。

方法名描述
newFixedThreadPool(int nThreads)获取固定数量的线程池。参数：指定线程池中线程的数量。
newCachedThreadPool()获得动态数量的线程池，如不够则创建新的，无上限。
newSingleThreadExecutor()创建单个线程的线程池，只有一个线程。
newScheduledThreadPool()创建固定大小的线程池，可以延迟或定时执行任务。
package Day19_thread2.pool;/*
 * @author  pyh
 * @since JDK1.8_241
    线程池：节省了线程的创建和销毁
 */
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Demo01 {
    public static void main(String[] args) {
        /*//返回包含单条线程的线程池
        ExecutorService pool = Executors.newSingleThreadExecutor();
        Task1 task = new Task1();
        for (int i = 1; i < 11; i++) {
            //提交需要执行的线程任务到线程池中
            pool.submit(task);
        }
        //关闭线程池
        pool.shutdown();*/

        /*//返回包含3条线程的线程池
        ExecutorService pool = Executors.newFixedThreadPool(3);
        Task1 task = new Task1();
        for (int i = 1; i < 11; i++) {
            //提交需要执行的线程任务到线程池中
            pool.submit(task);
        }
        //关闭线程池
        pool.shutdown();*/

        //创建一个带缓冲区的线程池，会根据需求创建线程
        ExecutorService pool = Executors.newCachedThreadPool();
        Task1 task = new Task1();
        for (int i = 1; i < 11; i++) {
            //提交需要执行的线程任务到线程池中
            pool.submit(task);
        }
        //关闭线程池
        pool.shutdown();
    }
}
class Task1 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
qq_43986982
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
主线程的子线程信息pool-1-thread-1
zwq1457的专栏
11-03 1万+
11-02 05:19:00.989 912 931 I am_anr : [0,31740,com.android.vending,952811205,Broadcast of Intent { act=android.intent.action.PACKAGE_REMOVED dat=package:com.android.vending flg=0x4000010 cmp=com.
Python多线程（三）——daemon属性
重邮皮皮尛的博客
01-16 2592
【代码】Python多线程（三）——daemon属性。
【大数据开发】Java语言基础——生产者消费者问题、Lock、线程停止的两种方式、守护线程、join、yied、优先级day21
白色风车
07-26 203
一、生产者消费者问题 （1）生产者负责生产，消费者负责消费 （2）生产者生产的产品，消费者消费的是产品 （3）生产者有生产任务，消费者有消费任务 （3）生产和消费可以同时进行 需要描述产品 定义生产者的任务 定义消费者的任务 Demo1 结果 解决方式：将if判断语句改为while语句 但是出现了死锁现象 截图 把if改为while，出现了死锁，原因线程 把notify()改成notifAll()，不该唤醒的线程也被唤醒了，程序性能降低了。解决这个问题需要使用jdk1.5提供的新的API 二、Lock jd
多线程学习-常用知识点(守护线程、线程状态、join、synchronized、lock)
harvey_huo的博客
04-19 113
守护线程和非守护线程 守护线程和主线程共存亡。最典型的守护线程是GC线程。 线程的七种状态 准备、就绪、运行、阻塞、（等待、超时等待）、结束 join方法 join作用是让其他线程进入等待状态，实现多线程同步操作。 线程安全问题 多个线程同时共享同一个全局变量或静态变量，做写的操作的时候会出现数据冲突问题。 synchronized和lock synchronized可以保证方法...
day24-多线程-设计模式.7z
06-29
还要关注线程间的通信（如使用`wait()`、`notify()`、`notifyAll()`等）、同步机制（如`synchronized`关键字、`Lock`接口等）、线程池的使用（`ExecutorService`、`ThreadPoolExecutor`等）以及线程安全的数据结构...
Java学习路线：day19
01-20
多线程线程的生命周期线程的同步同步代码块处理实现Runnable的线程安全问题同步代码块处理继承Thread类的线程安全问题同步方法处理实现Runnable的线程安全问题同步方法处理继承Thread类的线程安全问题线程安全的单例...
python多线程DAY04.txt
04-27
Lock lock.acquire() lock.release() 4. 什么是线程 threading Thread() t.start() t.join() t.name t.getName t.setName t.daemon t.is_alive() 5. 自定义线程类 继承 Thread 重写 run 6. 线程...
day06 线程、同步-每日作业卷-答案1
08-08
- **Lock接口及其实现**：如`ReentrantLock`，提供了比`synchronized`更细粒度的锁控制。 - **Atomic变量类**：如`AtomicInteger`，提供原子操作，避免并发时的冲突。 在实际编程中，根据需求选择合适的线程同步...
linux多线程编程的例程
03-23
2. **线程函数**：每个线程都有一个入口点，即线程函数。当新线程被创建时，会从这个函数开始执行。例如： ```cpp void* thread_function(void* arg) { // 线程执行的代码 } ``` 3. **线程参数**：`pthread_...
配置Java开发环境
Broken_x的博客
07-10 1452
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
最新发布
baina666的博客
07-12 317
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 420
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
java Object 转 Integer
servepeople的博客
07-09 1410
在 Java 中，可以通过多种方法将一个Object转换为Integer。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 2299
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
java占位符替换五种方式
weixin_61478518的博客
07-08 536
在业务开发中，经常需要输出文本串。其中，部分场景下大部分文本内容是一样的，只有少部分点是不一样。简单做法是直接拼接字段，但是这会有个问题。后面如果想要修改内容，那么每个地方都要修改，这不符合设计模式中的开闭原则，面向应该对扩展开放，对修改关闭。如何解决这个问题？先来看现实生活中的例子，个人信息填写。一般会要填写表格，已经定义好了姓名，性别，年龄等字段，只要填写对应的个人信息就好了。在程序开发中，我们会预先定义好一个字符串模板，需要改动的点使用占位符。
elk部署springboot
Chihirozy的博客
07-11 236
elk部署springboot。
AI技术的转变：从辨别式到生成式
学IT，找陈寒
07-09 3284
李彦宏在2024世界人工智能大会上的发言，提醒我们在AI技术发展的道路上，不要盲目追求技术本身或表面的用户数据，而应更多地关注技术的实际应用和产业价值。在大模型技术与个性化应用之间找到平衡，将是未来发展的关键。作为AI从业者和技术爱好者，我们应以务实的态度，探索AI技术在各个领域的实际应用，为产业发展和社会进步贡献力量。通过李彦宏的发言，我深刻认识到AI技术发展的方向和挑战，也更加坚定了自己在这一领域继续探索和创新的信心。未来，愿我们共同努力，推动AI技术更好地服务于社会和产业，为人类创造更美好的未来。
springboot中抽离日志
qq_24223159的博客
07-08 395
【代码】springboot中抽离日志。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值