java-Object-wait-notify dome

本文介绍了一个使用Java实现的并发锁测试案例。通过自定义的myWait和myNotify方法模拟线程间的等待与唤醒机制,利用AtomicInteger作为锁,并在多线程环境下运行,观察线程的执行顺序和锁的状态变化。
package cn.testin.test.service.test;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * lock test
 */
public class TestA {

    public static void main(String[] args){
        Runnable run = () -> {
            TestA a = new TestA();
            map.put(Thread.currentThread().getName(), a);
            a.myWait();
        };

        new Thread(run, "A").start();
        new Thread(run, "B").start();
        new Thread(run, "C").start();
        new Thread(run, "D").start();
        new Thread(run, "E").start();
        try {
            Thread.sleep(1000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(map);
        for (Map.Entry<String, TestA> entry : map.entrySet()) {
            entry.getValue().myNotify();
        }
    }

    private final AtomicInteger lock = new AtomicInteger(1);

    private final static Map<String, TestA> map =  new ConcurrentHashMap<>();

    private void myWait() {
        synchronized (this.lock) {
            try {
                System.out.println("incrementAndGet:" + this.lock.incrementAndGet());
                System.out.println("wait:"+ Thread.currentThread().getName());
                this.lock.wait();
                System.out.println("end:"+Thread.currentThread());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private void myNotify(){
        if (this.lock.get() > 1) {
            synchronized (this.lock) {
                System.out.println("decrementAndGet:" + this.lock.decrementAndGet());
                System.out.println("notify:"+ Thread.currentThread().getName());
                this.lock.notify();
            }
        }
    }
}

执行结果:

incrementAndGet:2
incrementAndGet:2
incrementAndGet:2
wait:D
incrementAndGet:2
wait:A
wait:B
incrementAndGet:2
wait:C
wait:E
{A=cn.testin.test.service.test.TestA@22927a81, B=cn.testin.test.service.test.TestA@78e03bb5, C=cn.testin.test.service.test.TestA@5e8c92f4, D=cn.testin.test.service.test.TestA@61e4705b, E=cn.testin.test.service.test.TestA@50134894}
decrementAndGet:1
notify:main
decrementAndGet:1
end:Thread[A,5,main]
notify:main
end:Thread[B,5,main]
decrementAndGet:1
notify:main
end:Thread[C,5,main]
decrementAndGet:1
notify:main
end:Thread[D,5,main]
decrementAndGet:1
notify:main
end:Thread[E,5,main]
 

<think> 我们正在回答用户关于JavaObject类和ArrayList类的介绍的问题。根据引用内容,我们可以提取以下信息: 关于ArrayList: - ArrayList是Java中的一个动态数组类,实现了List接口,可以存储任意类型的对象,大小可动态调整[^1]。 - 创建ArrayList对象:`ArrayList<E> objectName = new ArrayList<>();`,其中E是泛型,指定存储的数据类型[^2]。 - 初始容量和扩容:默认初始容量为0(注意:在Java 8中,如果未指定初始容量,初始容量为10?但引用[2]说默认初始容量0,这可能是指Java 7及以前版本?实际上,在Java 8中,默认构造的ArrayList初始数组是空数组,第一次添加元素时扩容到10)。当元素数量超过当前容量时,扩容为原容量的1.5倍。扩容操作会重新分配内存并复制元素,耗时。可指定初始容量:`new ArrayList<>(10)`[^2]。 - ArrayList提供添加、删除、修改、遍历等功能[^2]。 关于Object类: - Object类是所有Java类的根类,每个类都直接或间接继承自Object类。 - 引用[3]和[4]提到了Object转JSONObject和ArrayList,以及如何安全地将Object转化为ArrayList,但用户现在只要求介绍这两个类,因此我们重点介绍类本身。 由于用户要求介绍这两个类,我们需要分别介绍它们的基本概念、主要方法和使用注意事项。 回答结构: 1. Object类介绍 - 概念 - 主要方法(toString, equals, hashCode, getClass等) - 注意事项 2. ArrayList类介绍 - 概念 - 主要方法(add, remove, get, set等) - 初始容量和扩容(重点) - 注意事项 3. 两者的关系:ArrayList是Object的子类,所以ArrayList对象也是Object对象。 4. 相关问题生成 注意引用标注:在回答中,如果使用了引用中的内容,需要在句末标注引用标识,如[^1]。 下面开始回答: </think> ### Java中的Object类与ArrayList类详解 #### 一、Object类:Java的根类 `java.lang.Object`是所有Java类的超类(除`Object`自身外),每个类都直接或间接继承它。核心特性: 1. **基础方法**: ```java public boolean equals(Object obj) // 对象相等性比较 public int hashCode() // 返回对象哈希值 public String toString() // 返回对象字符串表示[^1] protected Object clone() throws CloneNotSupportedException // 对象克隆 ``` 2. **多线程支持**: ```java public final void wait() throws InterruptedException // 线程等待 public final void notify() // 唤醒单个等待线程 ``` 3. **类型操作**: ```java public final Class<?> getClass() // 获取对象运行时类 ``` > **关键作用**:提供默认实现(如`toString()`返回`类名@哈希值`),允许子类重写以实现定制行为[^4]。 #### 二、ArrayList类:动态数组实现 `java.util.ArrayList`是基于数组的动态列表,实现`List`接口。核心特性: 1. **初始化与构造**: ```java ArrayList<String> list = new ArrayList<>(); // 默认容量10 ArrayList<Integer> nums = new ArrayList<>(100); // 指定初始容量[^2] ``` 2. **扩容机制**(核心优势): - 默认初始容量:**10** - 扩容公式:$新容量 = 旧容量 + \left\lfloor \frac{旧容量}{2} \right\rfloor$ (如10→15→22→33) - 扩容代价:需复制原数组到新内存空间[^2] 3. **核心操作时间复杂度**: | 操作 | 时间复杂度 | 说明 | |------------|------------|--------------------------| | `get(i)` | $O(1)$ | 数组随机访问 | | `add(e)` | 均摊$O(1)$ | 尾部插入,触发扩容时$O(n)$ | | `add(i,e)` | $O(n)$ | 插入需移动后续元素 | | `remove(i)`| $O(n)$ | 删除需移动后续元素 | 4. **常用方法**: ```java list.add("Java"); // 尾部添加元素 list.add(0, "Python"); // 指定位置插入 list.remove(1); // 删除索引1的元素 String s = list.get(0); // 获取索引0的元素 int size = list.size(); // 获取元素数量[^2] ``` #### 三、Object与ArrayList的关系 1. **继承关系**:`ArrayList`间接继承`Object`(`ArrayList`→`AbstractList`→`Object`) 2. **类型转换**: ```java Object obj = new ArrayList<>(); // 向上转型(安全) // 向下转型需类型检查 if (obj instanceof ArrayList) { ArrayList<?> list = (ArrayList<?>) obj; } ``` 3. **JSON转换**(结合引用[3]): ```java Object data = getData(); // 可能返回ArrayList if (data instanceof ArrayList) { List<Map<String, Object>> list = (ArrayList) data; String name = list.get(0).get("name").toString(); } ``` #### 四、使用建议 1. **ArrayList优化**: - 预估数据量时指定初始容量(如`new ArrayList<>(1000)`)减少扩容次数[^2] - 频繁插入/删除时考虑`LinkedList` 2. **Object操作**: - 重写`equals()`时必须同步重写`hashCode()`[^4] - 优先使用泛型集合(如`ArrayList<String>`)避免强制类型转换 > **注意**:`ArrayList.toArray()`返回的是`Object[]`,需转型为具体类型数组。 --- ### 相关问题 1. 如何在ArrayList中安全存储混合数据类型? 2. 重写Object类的equals()方法时需要遵循哪些规范? 3. ArrayList和LinkedList在内存结构上有何本质区别? 4. 为什么ArrayList的随机访问比LinkedList快? 5. Java泛型如何解决ArrayList的类型安全问题?
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值