Java多线程解决多线程安全问题

简介: 1.理解多线程原理2.掌握多线程的实现方法3.掌握多线程的控制方法4.能够通过多线程解决实际问题。

1、线程安全

线程安全的三种解决方法:同步代码块,同步方法和lock锁。

线程安全是多线程编程时的计算机程序代码中的一个概念。在拥有共享数据的多条线程并行执行的程序中,线程安全的代码会通过同步机制保证各个线程都可以正常且正确的执行,不会出现数据污染等意外情况。

1、同步代码块

详细代码:

publicclass同步代码块 {
publicstaticvoidmain(String[] args) {
TicketWindow1task=newTicketWindow1();
newThread(task,"窗口一").start();
newThread(task,"窗口二").start();
newThread(task,"窗口三").start();
    }
}
classTicketWindow1implementsRunnable{
privateinttickets=10;
Objectlock=newObject();
publicvoidrun() {
while(true){
synchronized (lock) {
try {
Thread.sleep(10);
                } catch (InterruptedExceptione) {
// TODO Auto-generated catch blocke.printStackTrace();
                }
if(tickets>0){
System.out.println(Thread.currentThread().getName()+"--卖出的票"+tickets--);
            }
        }
    }
  }
}

image.png

2、同步方法

详细代码:

publicclass同步方法 {
publicstaticvoidmain(String[] args) {
TicketWindow2task=newTicketWindow2();
newThread(task,"窗口一").start();
newThread(task,"窗口二").start();
newThread(task,"窗口三").start();
    }
}
classTicketWindow2implementsRunnable{
privateinttickets=10;
@Overridepublicvoidrun() {
// TODO Auto-generated method stubwhile(true){
SendTask();
        }
    }
privatesynchronizedvoidSendTask() {
// TODO Auto-generated method stubtry {
Thread.sleep(10);
        } catch (InterruptedExceptione) {
// TODO Auto-generated catch blocke.printStackTrace();
        }
if(tickets>0){
System.out.println(Thread.currentThread().getName()+"--卖出的票"+tickets--);
        }else{
System.exit(0);
        }
    }
}

image.png

3、lock锁


详细代码:

importjava.util.concurrent.locks.Lock;
importjava.util.concurrent.locks.ReentrantLock;
publicclasslock锁 {
publicstaticvoidmain(String[] args) {
TicketWindow3task=newTicketWindow3();
newThread(task,"窗口一").start();
newThread(task,"窗口二").start();
newThread(task,"窗口三").start();
    }
}
classTicketWindow3implementsRunnable{
privateinttickets=10;
Lockl=newReentrantLock();
publicvoidrun() {
while(true){
l.lock();
try {
Thread.sleep(10);
                } catch (InterruptedExceptione) {
// TODO Auto-generated catch blocke.printStackTrace();
                }
if(tickets>0){
System.out.println(Thread.currentThread().getName()+"--卖出的票"+tickets--);
            }
l.unlock();
        }
    }
}

image.png


2、死锁

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

publicclass线程死锁implementsRunnable {
staticObjectchopsticks=newObject();
staticObjectknifeAndFork=newObject();
privatebooleanflag;
线程死锁(booleanflag){
this.flag=flag;
    }
@Overridepublicvoidrun() {
// TODO Auto-generated method stubif(flag){
while(true){
synchronized (chopsticks) {
System.out.println(Thread.currentThread().getName()+"---if---chopsticks");
synchronized (knifeAndFork) {
System.out.println(Thread.currentThread().getName()+"---if---knifeAndFork");
                    }
                }
            }
        }else{
while(true){
synchronized (knifeAndFork) {
System.out.println(Thread.currentThread().getName()+"---else---knifeAndFork");
synchronized (chopsticks) {
System.out.println(Thread.currentThread().getName()+"---else---chopsticks");
            }
        }
    }
  }
 }
}
publicclassExample {
publicstaticvoidmain(String[] args) {
线程死锁d1=new线程死锁(true);
线程死锁d2=new线程死锁(false);
newThread(d1,"Chinese").start();
newThread(d2,"American").start();
    }
}

image.png

3、线程通信

ITC,是Inter-Thread Communication的缩写,意思是线程间通信。

publicclassMyThread {
publicstaticObjectobject=newObject();
publicstaticvoidmain(String[] args) {
Thread1t1=newThread1();
Thread2t2=newThread2();
t1.start();
t2.start();
    }
staticclassThread1extendsThread{
publicvoidrun() {
synchronized (object) {
System.out.println("线程"+Thread.currentThread().getName()+"获取到了锁");
try{
System.out.println("线程"+Thread.currentThread().getName()+"阻塞并释放锁。。。");
object.wait();
            }catch(InterruptedExceptione){
            }
System.out.println("线程"+Thread.currentThread().getName()+"执行完成。。。。。。");
    }
}
staticclassThread2extendsThread{
publicvoidrun() {
synchronized (object) {
System.out.println("线程"+Thread.currentThread().getName()+"获取到了锁");
object.notify();
System.out.println("线程"+Thread.currentThread().getName()+"唤醒了正在wait的线程");
        }
System.out.println("线程"+Thread.currentThread().getName()+"执行完成。。。。。。");
       }
       }
    }
}

image.png

相关文章
|
3天前
|
Java
Java—多线程实现生产消费者
本文介绍了多线程实现生产消费者模式的三个版本。Version1包含四个类:`Producer`(生产者)、`Consumer`(消费者)、`Resource`(公共资源)和`TestMain`(测试类)。通过`synchronized`和`wait/notify`机制控制线程同步,但存在多个生产者或消费者时可能出现多次生产和消费的问题。 Version2将`if`改为`while`,解决了多次生产和消费的问题,但仍可能因`notify()`随机唤醒线程而导致死锁。因此,引入了`notifyAll()`来唤醒所有等待线程,但这会带来性能问题。
Java—多线程实现生产消费者
|
5天前
|
安全 Java Kotlin
Java多线程——synchronized、volatile 保障可见性
Java多线程中,`synchronized` 和 `volatile` 关键字用于保障可见性。`synchronized` 保证原子性、可见性和有序性,通过锁机制确保线程安全;`volatile` 仅保证可见性和有序性,不保证原子性。代码示例展示了如何使用 `synchronized` 和 `volatile` 解决主线程无法感知子线程修改共享变量的问题。总结:`volatile` 确保不同线程对共享变量操作的可见性,使一个线程修改后,其他线程能立即看到最新值。
|
5天前
|
消息中间件 缓存 安全
Java多线程是什么
Java多线程简介:本文介绍了Java中常见的线程池类型,包括`newCachedThreadPool`(适用于短期异步任务)、`newFixedThreadPool`(适用于固定数量的长期任务)、`newScheduledThreadPool`(支持定时和周期性任务)以及`newSingleThreadExecutor`(保证任务顺序执行)。同时,文章还讲解了Java中的锁机制,如`synchronized`关键字、CAS操作及其实现方式,并详细描述了可重入锁`ReentrantLock`和读写锁`ReadWriteLock`的工作原理与应用场景。
|
5天前
|
安全 Java 编译器
深入理解Java中synchronized三种使用方式:助您写出线程安全的代码
`synchronized` 是 Java 中的关键字,用于实现线程同步,确保多个线程互斥访问共享资源。它通过内置的监视器锁机制,防止多个线程同时执行被 `synchronized` 修饰的方法或代码块。`synchronized` 可以修饰非静态方法、静态方法和代码块,分别锁定实例对象、类对象或指定的对象。其底层原理基于 JVM 的指令和对象的监视器,JDK 1.6 后引入了偏向锁、轻量级锁等优化措施,提高了性能。
22 3
|
5天前
|
存储 安全 Java
Java多线程编程秘籍:各种方案一网打尽,不要错过!
Java 中实现多线程的方式主要有四种:继承 Thread 类、实现 Runnable 接口、实现 Callable 接口和使用线程池。每种方式各有优缺点,适用于不同的场景。继承 Thread 类最简单,实现 Runnable 接口更灵活,Callable 接口支持返回结果,线程池则便于管理和复用线程。实际应用中可根据需求选择合适的方式。此外,还介绍了多线程相关的常见面试问题及答案,涵盖线程概念、线程安全、线程池等知识点。
65 2
|
3天前
|
缓存 安全 Java
【JavaEE】——单例模式引起的多线程安全问题:“饿汉/懒汉”模式,及解决思路和方法(面试高频)
单例模式下,“饿汉模式”,“懒汉模式”,单例模式下引起的线程安全问题,解锁思路和解决方法
|
3天前
|
Java 调度
【JavaEE】——线程的安全问题和解决方式
【JavaEE】——线程的安全问题和解决方式。为什么多线程运行会有安全问题,解决线程安全问题的思路,synchronized关键字的运用,加锁机制,“锁竞争”,几个变式
|
7月前
|
存储 安全 Java
深入理解Java并发编程:线程安全与锁机制
【5月更文挑战第31天】在Java并发编程中,线程安全和锁机制是两个核心概念。本文将深入探讨这两个概念,包括它们的定义、实现方式以及在实际开发中的应用。通过对线程安全和锁机制的深入理解,可以帮助我们更好地解决并发编程中的问题,提高程序的性能和稳定性。
|
4月前
|
存储 安全 Java
解锁Java并发编程奥秘:深入剖析Synchronized关键字的同步机制与实现原理,让多线程安全如磐石般稳固!
【8月更文挑战第4天】Java并发编程中,Synchronized关键字是确保多线程环境下数据一致性与线程安全的基础机制。它可通过修饰实例方法、静态方法或代码块来控制对共享资源的独占访问。Synchronized基于Java对象头中的监视器锁实现,通过MonitorEnter/MonitorExit指令管理锁的获取与释放。示例展示了如何使用Synchronized修饰方法以实现线程间的同步,避免数据竞争。掌握其原理对编写高效安全的多线程程序极为关键。
71 1
|
5月前
|
安全 Java 开发者
Java并发编程中的线程安全问题及解决方案探讨
在Java编程中,特别是在并发编程领域,线程安全问题是开发过程中常见且关键的挑战。本文将深入探讨Java中的线程安全性,分析常见的线程安全问题,并介绍相应的解决方案,帮助开发者更好地理解和应对并发环境下的挑战。【7月更文挑战第3天】
109 0