JUC设计模式之保护性暂停(代码)

package com.mode;

import java.util.Hashtable;
import java.util.Map;
import java.util.Set;

public class suspension {
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i <3 ; i++) {
           reciver t =new reciver();
           t.setName(""+i);
           t.start();
        }
        Thread.sleep(1000);
        for(int id:emailbox.getids()){
           Postman postman= new Postman(id,"内容:"+id);
           postman.setName(""+id);
           postman.start();
        }
    }
}
class reciver extends Thread{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"创建邮箱");
        protect pt=emailbox.Createprotect();
        System.out.println(Thread.currentThread().getName()+"开始收信");
        Object message=pt.getResults(2000);
        System.out.println(Thread.currentThread().getName()+"收到信:id="+pt.getId()+"\t 内容:"+message);
    }
}
class Postman extends Thread{
    private int id;
    private String mail;

    public Postman(int id, String mail) {
        this.id = id;
        this.mail = mail;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"开始送信..");
        protect pt=emailbox.get(id);
        System.out.println("送信id:"+id+"\t "+mail);
        pt.stop(mail);
    }
}
class emailbox{
    private static int id=0;
    private static Map<Integer,protect> map=new Hashtable<>();
    public static synchronized int generater(){
            id++;
            return id;
    }
    public static protect get(int id){
        return map.remove(id);
    }
    public static synchronized protect Createprotect(){
        protect p=new protect(generater());
        map.put(p.getId(),p);
        return p;
    }
    public static Set<Integer> getids(){
        return map.keySet();
    }
}
class protect{
    private int id=0;

    public int getId() {
        return id;
    }

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

    public Object getResult() {
        return result;
    }

    public void setResult(Object result) {
        this.result = result;
    }

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

    private Object result;
    public Object getResults(long timeout){
        synchronized (this){
            long now=System.currentTimeMillis();
            long pass=0;
            while (result==null){
                long waittime=timeout-pass;
                if(waittime<=0) break;
                try {
                    wait(waittime);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                pass=System.currentTimeMillis()-now;
            }
            return result;
        }
    }
    public void stop(String message){
        synchronized (this){
            result=message;
            notifyAll();
        }
    }
}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: JUCJava.util.concurrent的缩写,提供了许多并发编程的工具类,其中就包括了解决多线程原子性问题的类。 在JUC中,提供了多个原子类,例如AtomicInteger、AtomicLong等,这些类可以保证对其操作的原子性,也就是说,对它们进行读写操作时,不会出现数据不一致的情况。 下面是一个使用AtomicInteger解决多线程原子性问题的示例代码: ```java import java.util.concurrent.atomic.AtomicInteger; public class AtomicExample { private AtomicInteger count = new AtomicInteger(0); public void increment() { count.incrementAndGet(); } public int getCount() { return count.get(); } } ``` 在这个示例中,count是一个AtomicInteger类型的变量,它的incrementAndGet()方法可以保证对它进行操作的原子性,即使有多个线程同时对它进行操作,也不会出现数据不一致的情况。 因此,使用JUC提供的原子类可以很方便地解决多线程原子性问题。 ### 回答2: JUCJava Util Concurrent)是Java并发实用工具包,在解决多线程原子性问题上提供了丰富的解决方案。下面是JUC中常用的两种解决方案,以代码示例的形式展示。 1. synchronized关键字 synchronized关键字是Java中最基本的同步机制,通过给关键代码块或方法加锁,确保同一时间只能有一个线程执行该代码块或方法,以实现原子性操作。 ```java public class Counter { private int count; public synchronized void increment() { count++; } } ``` 2. Atomic类 Atomic类是JUC中提供的一组原子操作类,它们利用底层的CAS(Compare and Swap)机制实现原子性操作。CAS机制通过比较内存中的值与期望值,若相等则修改为新值,若不相等则重新尝试,直至更新成功。Atomic类可实现基本类型和引用类型的原子操作。 ```java import java.util.concurrent.atomic.AtomicInteger; public class Counter { private AtomicInteger count = new AtomicInteger(0); public void increment() { count.incrementAndGet(); } } ``` 以上是JUC解决多线程原子性问题的两个常用方案。synchronized关键字通过加锁实现,而Atomic类则利用CAS机制实现,二者都能保证多线程环境下的原子性操作。根据具体的业务场景和性能要求,选择合适的方式解决多线程原子性问题。 ### 回答3: JUCJava并发编程工具包)是Java提供的用于解决多线程并发问题的工具包,其中包含了很多用于处理线程安全的类和接口。 JUC中解决多线程原子性问题的方式主要是通过提供原子类来实现。原子类是一种可以单独访问和修改的变量类型,它们可以以原子方式执行操作,保证了操作的原子性。 下面是一个使用JUC提供的原子类AtomicInteger来解决多线程原子性问题的示例代码: ```java import java.util.concurrent.atomic.AtomicInteger; public class AtomicityExample { private static AtomicInteger counter = new AtomicInteger(0); public static void main(String[] args) throws InterruptedException { Thread thread1 = new Thread(new IncrementTask()); Thread thread2 = new Thread(new IncrementTask()); thread1.start(); thread2.start(); thread1.join(); thread2.join(); System.out.println("Counter: " + counter); } static class IncrementTask implements Runnable { @Override public void run() { for (int i = 0; i < 10000; i++) { counter.incrementAndGet(); // 使用原子方式将当前值加1 } } } } ``` 在上述示例代码中,使用AtomicInteger类来声明了一个原子变量counter。在IncrementTask任务中,每次循环通过调用incrementAndGet()方法对counter的值进行原子自增操作。 使用JUC提供的原子类可以确保多线程环境下对变量的操作是原子性的,避免了出现竞态条件等线程安全问题。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值