Java 泛型 Generic機(jī)制實(shí)例詳解
泛型是什么？
使用泛型可以指定類(lèi)型變量，從而讓代碼可以對(duì)不同類(lèi)型的對(duì)象進(jìn)行重用。以及，還可以讓編譯器更好的了解類(lèi)型，從而避免強(qiáng)制類(lèi)型轉(zhuǎn)換，提升代碼的安全性。
類(lèi)型變量就是尖括號(hào) <>中的變量，類(lèi)型變量的命名規(guī)范是使用大寫(xiě)字母，例如 E 表示元素類(lèi)型，K、V 分別表示鍵和值類(lèi)型，T 和相鄰的 U、S 表示任意類(lèi)型。當(dāng)然你也可以起其他的名字，編譯器對(duì)此并沒(méi)有強(qiáng)制限制，但是還是按照規(guī)范來(lái)。
泛型類(lèi)
泛型類(lèi)（generic class）就是有一個(gè)或多個(gè)類(lèi)型變量的類(lèi)。例如下面的 Pair 類(lèi)，就有兩個(gè)類(lèi)型變量，分別是 T 和 U：
public class Pair<T, U> {
public T first;
public U second;
public Pair(T first, U second) {
this.first = first;
this.second = second;
}
}
在使用時(shí)，就可以傳入任意的類(lèi)型。例如：
Pair<Integer, String> pair = new Pair<>(1, "A");
思考一下，如果沒(méi)有泛型的存在，那么當(dāng)我們要操作不同類(lèi)型的對(duì)象時(shí)，要么為每種類(lèi)型都創(chuàng)建一個(gè)類(lèi)，但是這樣就會(huì)存在大量的重復(fù)代碼，不容易維護(hù)。要么就直接使用對(duì)象的頂級(jí)父類(lèi) Object 類(lèi)，但是這樣的話在使用時(shí)就需要進(jìn)行強(qiáng)制轉(zhuǎn)換，存在安全問(wèn)題，即使每次強(qiáng)轉(zhuǎn)前進(jìn)行判斷，也會(huì)存在重復(fù)代碼和遺漏的風(fēng)險(xiǎn)。
說(shuō)回泛型類(lèi)，泛型類(lèi)的類(lèi)型變量是定義在類(lèi)名后面，在整個(gè)類(lèi)中都可以使用定義的類(lèi)型變量。所以在選擇使用泛型類(lèi)時(shí)，泛型變量應(yīng)該是和類(lèi)所關(guān)聯(lián)的。如果僅與方法關(guān)聯(lián)，那么可以使用泛型方法。
泛型方法
泛型方法的類(lèi)型參數(shù)是定義在方法返回類(lèi)型的前面的，只在當(dāng)前方法中可以使用。例如：
public static <T> T getMiddle(T... a) {
return a[a.length / 2];
}
泛型方法可以在普通類(lèi)中定義，也可以在泛型類(lèi)中定義。如果泛型變量?jī)H在方法內(nèi)會(huì)用到，就可以考慮使用泛型方法。
類(lèi)型變量的限制
默認(rèn)情況下，類(lèi)型變量可以是任何類(lèi)型。但是有時(shí)候，我們需要限制類(lèi)型變量的類(lèi)型。此時(shí)可以通過(guò) extends關(guān)鍵字來(lái)限制：
<T extends UpperBoundType>限制泛型類(lèi)型為特定類(lèi)型或者特定類(lèi)型的子類(lèi)
例如，假設(shè)我們有一個(gè) Printer 類(lèi)，我們只需要這個(gè)類(lèi)打印動(dòng)物的信息，那么就可以使用 <T extends Animal> 來(lái)限制只能接收 Animal 或其實(shí)現(xiàn)類(lèi)：
public interface Animal {
String getName();
}
public static class Printer<T extends Animal> {
public void print(T t) {
System.out.println(t.getName());
}
}
public static class Dog implements Animal {
@Override
public String getName() {
return "Woof";
}
}
public static class Cat implements Animal {
@Override
public String getName() {
return "Meow";
}
}
public static void main(String[] args) {
Printer<Animal> animalPrinter = new Printer<>();
animalPrinter.print(new Dog());
animalPrinter.print(new Cat());
animalPrinter.print(new People("Abc")); // 如果試圖傳入一個(gè)其他類(lèi)型，則會(huì)編譯失敗
}
一個(gè)類(lèi)型變量，可以指定多個(gè)限制類(lèi)型。例如：
public class Printer<T extends Dog & Animal> {
...
}
上面的限制的意思是，類(lèi)型變量必須是 Dog 或其子類(lèi)，并且實(shí)現(xiàn)了 Animal 接口。需要注意的是，在指定多個(gè)限制的類(lèi)型時(shí)，除了第一個(gè)限制類(lèi)型可以是類(lèi)以外，其他的限制類(lèi)型必須是接口類(lèi)型。這是因?yàn)?Java 是不支持多重繼承的。
類(lèi)型擦除
由于泛型是在 Java 1.5 才推出的，所以 Java 為了保證在之前版本上的兼容性，泛型實(shí)際上在 JVM 中是沒(méi)有的！
也就是說(shuō)，編譯器在編譯時(shí)會(huì)擦除掉泛型的參數(shù)類(lèi)型，并提供一個(gè)相應(yīng)的原始類(lèi)型（raw type），這個(gè)原始類(lèi)型的名字就是去掉類(lèi)型參數(shù)后的泛型類(lèi)型名。類(lèi)型變量會(huì)被擦除（erased），并替換為其限定類(lèi)型，沒(méi)有限定類(lèi)型則替換為 Object 類(lèi)型。
舉個(gè)例子，如果我們定義了一個(gè)泛型類(lèi)：
public class Printer<T> {
...
}
那么當(dāng)類(lèi)型擦除后，實(shí)際上就變?yōu)榱?Printer<Object> 類(lèi)型。
如果指定了限定類(lèi)型，例如：
public class Printer<T extends Animal> {
...
}
那么擦除后，就變?yōu)榱?Printer<Animal> 類(lèi)型。
如果指定了多個(gè)限定的類(lèi)型，那么擦除后就會(huì)是第一個(gè)限定的類(lèi)型。例如：
public class Printer<T extends Dog & Animal> {
...
}
擦除后就變?yōu)榱?Printer<Dog>類(lèi)型。
Java 泛型的很多限制都是由于泛型擦除導(dǎo)致的，下面會(huì)詳細(xì)介紹下泛型的局限性。
通配符
通配符（Wildcard）就是 Java 泛型中的問(wèn)號(hào) ? 。要想知道通配符是要解決什么樣的問(wèn)題，我覺(jué)得首先需要知道什么是 Variance（不知道這個(gè)正確的譯名是什么，如有知道請(qǐng)留言）？
提到 Variance 必須先提到子類(lèi)型（subtyping），子類(lèi)型是面向?qū)ο笾蓄?lèi)型多態(tài)的其中一種表現(xiàn)形式，主要用于描述 is-a 這樣的關(guān)系，例如 S 是 T 的子類(lèi)型，那么 S is a subtype of T。
Variance 指的是如何根據(jù)組成類(lèi)型之間的子類(lèi)型關(guān)系，來(lái)確定更復(fù)雜的類(lèi)型之間的子類(lèi)型關(guān)系。
上面這段話比較繞，舉個(gè)實(shí)際的例子來(lái)說(shuō)，Variance 指的就是當(dāng)子類(lèi)型在更復(fù)雜的場(chǎng)景下，例如 If S is a subtype of T，那 Generic<S> is subtype of Generic<T> 這種關(guān)系是否還能成立。
Variance 分為下面幾種形式：
- 不變（Invariance）：如果 B 是 A 的子類(lèi)型，那么
Generic<B>不是Generic<A>的子類(lèi)型。 - 協(xié)變（Covariance）：如果 B 是 A 的子類(lèi)型，那么
Generic<B>是Generic<A>的子類(lèi)型。 - 逆變（Contravariance）：如果 B 是 A 的子類(lèi)型，那么
Generic<A>是Generic<B>的子類(lèi)型（逆變就是逆轉(zhuǎn)了子類(lèi)型關(guān)系）。 - 雙變（Bi-variance）：Java 中不存在雙變，因此不討論。
在 Java 當(dāng)中，泛型是不變的，這也就意味著下面這段看似沒(méi)問(wèn)題的代碼會(huì)報(bào)錯(cuò)：
List<Dog> dogs = new ArrayList<>(); List<Animal> animals = dogs; // 編譯報(bào)錯(cuò)
因?yàn)榘凑詹蛔兊恼f(shuō)明，List<Dog> 根本就不是 List<Animal> 的子類(lèi)型，所以自然就不能賦值了。
Java 中的泛型采用不變性是為了保證類(lèi)型安全。不過(guò)不變性雖然保證了類(lèi)型安全，但是也讓靈活性大大降低。為此，Java 提供了通配符，可以解除部分這種限制，也不損失安全性。
上界通配符
上界通配符的形式為：? extends Type，使用上限通配符可以將類(lèi)型參數(shù)變?yōu)閰f(xié)變的，這就可以讓原本無(wú)法賦值的類(lèi)型可以正常賦值了。但是這在解除不變性限制的同時(shí)，也帶來(lái)了新的限制，就是參數(shù)類(lèi)型只能作為返回值類(lèi)型，無(wú)法作為入?yún)⒌念?lèi)型。例如：
List<? extends Animal> animals = new ArrayList<Dog>(); // 可以正確賦值了 animals.add(new Dog()); // 編譯錯(cuò)誤，類(lèi)型不匹配，無(wú)法寫(xiě)入，除非寫(xiě)入 null（也就是參數(shù)類(lèi)型無(wú)法作為入?yún)⒌念?lèi)型） Animal animal = animals.get(0); // 可以獲?。ㄒ簿褪菂?shù)類(lèi)型可作為返回值類(lèi)型）
這就叫當(dāng)上帝給你關(guān)了一扇門(mén)，同時(shí)會(huì)幫你打開(kāi)一扇窗。盡管窗戶有個(gè)洞，但總比沒(méi)有好吧？你說(shuō)是不是？
下界通配符
下界通配符的形式為：? super Type，使用下界通配符可以將類(lèi)型參數(shù)變?yōu)槟孀兊?，也就是說(shuō)顛倒了類(lèi)型關(guān)系，父類(lèi)型可以賦值給子類(lèi)型了！例如：
List<Animal> animals = new ArrayList<>(); List<? super Dog> dogs = animals; // 可以正確賦值！
看起來(lái)挺神奇的吧！這種方式同樣也帶來(lái)了新的限制，在使用這種變量的時(shí)候，不可以調(diào)用返回值包含類(lèi)型參數(shù)的方法，也不能獲得包含類(lèi)型參數(shù)的字段值。簡(jiǎn)單來(lái)說(shuō)，就是只能作為輸入，但是不能輸出。例如：
dogs.add(new Dog()); // 可以寫(xiě)入 Dog dog = dogs.get(0); // 編譯報(bào)錯(cuò)，類(lèi)型不匹配： Required type: Dog Provided: capture of ? super Dog
對(duì)于獲取時(shí)編譯報(bào)類(lèi)型不匹配的問(wèn)題，其實(shí)可以通過(guò)類(lèi)型強(qiáng)制轉(zhuǎn)換來(lái)解決。
無(wú)界通配符
無(wú)界通配符的形式就是一個(gè)單獨(dú)的問(wèn)號(hào) ?。當(dāng)我們對(duì)類(lèi)型參數(shù)一無(wú)所知，但仍然希望以安全的方式使用它時(shí)，則可以考慮使用無(wú)界通配符。例如：
public static boolean hasNull(Pair<?> p) {
return p.first != null && p.second != null;
}
反射和泛型
因?yàn)榉盒筒脸詿o(wú)法在反射時(shí)獲取泛型類(lèi)型。但是擦除的類(lèi)依然保留原先泛型的微弱記憶。例如，如果定義了以下泛型方法：
public static <T extends Comparable<? super T>> T min(T[] a)
那么，可以通過(guò)反射可以獲取到以下信息：
public static Comparable min(Comparable[] a)
也就是說(shuō)，我們可以重新構(gòu)造實(shí)現(xiàn)者聲明的泛型類(lèi)和方法的有關(guān)內(nèi)容。但是，不會(huì)知道對(duì)于特定的對(duì)象或方法調(diào)用會(huì)如何解析類(lèi)型參數(shù)。
為了表述泛型類(lèi)型聲明，可以使用 java.lang.reflect包中的接口 Type。這個(gè)接口包含以下子類(lèi)型：
- Class 類(lèi)：描述具體類(lèi)型
- TypeVariable 接口：描述類(lèi)型變量（如
T extends Comparable<? super T>） - WildcardType 接口：描述通配符（如
? super T） - ParameterizedType 接口：描述泛型類(lèi)或接口類(lèi)型（如
Comparable<? super T>） - GenericArrrayType 接口：描述泛型數(shù)組（如
T[]）
下面的這個(gè)示例程序，就是通過(guò)反射來(lái)打印指定類(lèi)的信息：
public class GenericReflectionTest {
public static void main(String[] args) {
String className;
try (Scanner scanner = new Scanner(System.in)) {
System.out.println("Enter class name (e.g., java.util.Collections): ");
className = scanner.next();
}
try {
Class<?> cl = Class.forName(className);
ClassPrinter.print(cl);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
public static class ClassPrinter {
public static void print(Class<?> cl) {
System.out.print(cl);
printTypes(cl.getTypeParameters(), "<", ", ", ">", true);
final Type sc = cl.getGenericSuperclass();
if (sc != null) {
System.out.print(" extends ");
printType(sc, false);
}
printTypes(cl.getGenericInterfaces(), " implements ", ", ", "", false);
System.out.print(" {");
System.out.println();
final Method[] methods = cl.getDeclaredMethods();
for (int i = 0; i < methods.length; i++) {
final Method method = methods[i];
printMethod(method);
if (i < methods.length - 1) {
System.out.println();
}
}
System.out.println();
System.out.print("}");
}
private static void printTypes(Type[] types, String pre, String sep, String suf, boolean isDefinition) {
if (pre.equals(" extends ") && Arrays.equals(types, new Type[]{Object.class})) {
return;
}
if (types.length > 0) {
System.out.print(pre);
}
for (int i = 0; i < types.length; i++) {
if (i > 0) {
System.out.print(sep);
}
printType(types[i], isDefinition);
}
if (types.length > 0) {
System.out.print(suf);
}
}
private static void printType(Type type, boolean isDefinition) {
if (type instanceof Class) { // 具體類(lèi)型
Class<?> cl = (Class<?>) type;
System.out.print(cl.getName());
} else if (type instanceof TypeVariable) { // 類(lèi)型變量
TypeVariable<?> tv = (TypeVariable<?>) type;
System.out.print(tv.getName());
if (isDefinition) {
printTypes(tv.getBounds(), " extends ", " & ", "", false);
}
} else if (type instanceof WildcardType) { // 通配符
WildcardType wt = (WildcardType) type;
System.out.print("?");
printTypes(wt.getUpperBounds(), " extends ", " & ", "", false);
printTypes(wt.getLowerBounds(), " super ", " & ", "", false);
} else if (type instanceof ParameterizedType) { // 泛型類(lèi)或接口類(lèi)型
ParameterizedType pt = (ParameterizedType) type;
Type ownerType = pt.getOwnerType();
if (ownerType != null) {
printType(ownerType, false);
}
printType(pt.getRawType(), false);
printTypes(pt.getActualTypeArguments(), "<", ", ", ">", false);
} else if (type instanceof GenericArrayType) { // 泛型數(shù)組
GenericArrayType gat = (GenericArrayType) type;
printType(gat.getGenericComponentType(), isDefinition);
System.out.print("[]");
} else {
System.out.print("unknown type: " + type);
}
}
private static void printMethod(Method m) {
final String name = m.getName();
System.out.print(" ");
System.out.print(Modifier.toString(m.getModifiers()));
System.out.print(" ");
printTypes(m.getTypeParameters(), "<", ", ", ">", true);
printType(m.getGenericReturnType(), false);
System.out.print(" ");
System.out.print(name);
System.out.print("(");
printTypes(m.getGenericParameterTypes(), "", ", ", "", false);
System.out.print(")");
}
}
}
以下面的這個(gè)測(cè)試類(lèi)為例：
public class TestClass<T extends Comparable<? super T>> implements Cloneable {
public void test(T t) {
System.out.println(t);
}
}
運(yùn)行上面的程序的輸出結(jié)果是：
class com.airsaid.java.samples.generic.TestClass<T extends java.lang.Comparable<? super T>> extends java.lang.Object implements java.lang.Cloneable {
public void test(T)
}
可以看到，可以獲取到該泛型類(lèi)所定義的泛型信息。
類(lèi)型字面量
有時(shí)候，我們確實(shí)需要在運(yùn)行時(shí)獲取泛型的參數(shù)類(lèi)型，那么真的就沒(méi)有辦法了嗎？
答案是有的，在上面反射的例子中我們可以看到，字節(jié)碼當(dāng)中其實(shí)保存了部分的泛型信息（簽名信息）。
舉一個(gè)實(shí)際場(chǎng)景的例子，Gson 這個(gè)框架相信大家都用過(guò)。在進(jìn)行反序列化時(shí)，有多個(gè)重載方法：
fromJson(String json, Class cl)
fromJson(String json, TypeToken type)
當(dāng)使用第一個(gè)方法時(shí)，如果第二個(gè)參數(shù)是一個(gè)泛型類(lèi)的 class 對(duì)象，那么就會(huì)出現(xiàn)問(wèn)題。例如下面的這段示例代碼：
Foo<DataBean> foo = new Foo<DataBean>(); gson.fromJson(json, foo.getClass());
這是因?yàn)闊o(wú)法獲取到 Foo 類(lèi)的泛型參數(shù) DataBean。
因此，Gson 提供了 TypeToken 類(lèi)來(lái)處理這種問(wèn)題。使用起來(lái)是這樣的：
Foo<DataBean> foo = new Foo<DataBean>();
gson.fromJson(json, new TypeToken<Foo<DataBean>>(){});
下面是我簡(jiǎn)化過(guò)后的 TypeToken 源碼：
public class TypeToken<T> {
private final Type type;
protected TypeToken() {
this.type = getTypeTokenTypeArgument();
}
public Type getType() {
return type;
}
private Type getTypeTokenTypeArgument() {
final Type superclass = getClass().getGenericSuperclass();
if (superclass instanceof ParameterizedType) {
ParameterizedType parameterized = (ParameterizedType) superclass;
if (parameterized.getRawType() == TypeToken.class) {
return parameterized.getActualTypeArguments()[0];
}
} else if (superclass == TypeToken.class) {
throw new IllegalStateException("TypeToken must be created with a type argument: new TypeToken<...>() {}; "
+ "When using code shrinkers (ProGuard, R8, ...) make sure that generic signatures are preserved.");
}
throw new IllegalStateException("Must only create direct subclasses of TypeToken");
}
}
TypeToken 的原理就是創(chuàng)建了一個(gè)匿名子類(lèi)對(duì)象，然后通過(guò) getGenericSuperclass()方法獲取其泛型父類(lèi)，再獲取其中定義的參數(shù)化類(lèi)型的類(lèi)型參數(shù)。通過(guò)這種方式，就可以獲取到 TypeToken 所定義的泛型類(lèi)型了：
public class TypeTokenTest {
public static void main(String[] args) {
TypeToken<?> typeToken = new TypeToken<List<String>>() {};
System.out.println(typeToken.getType()); // java.util.List<java.lang.String>
}
}
限制和局限性
不能使用基本類(lèi)型實(shí)例化類(lèi)型參數(shù)
泛型的類(lèi)型參數(shù)不可以使用基本類(lèi)型，例如 Pair<int>，這是因?yàn)轭?lèi)型擦除后類(lèi)型變?yōu)榱?Object，而 Object 無(wú)法存儲(chǔ)基本類(lèi)型數(shù)值。對(duì)于這種情況，我們需要使用基本類(lèi)型對(duì)應(yīng)的包裝類(lèi)型。
運(yùn)行時(shí)類(lèi)型查詢(xún)只適用于原始類(lèi)型
同樣也是由于類(lèi)型擦除導(dǎo)致的問(wèn)題，如果要在代碼中進(jìn)行判斷是否是某個(gè)泛型類(lèi)型，這是無(wú)法做到的。例如：
if (a instanceof Pair<String>) // 錯(cuò)誤
不能創(chuàng)建參數(shù)化類(lèi)型的數(shù)組
還是由于類(lèi)型擦除導(dǎo)致的問(wèn)題，無(wú)法實(shí)例化參數(shù)化類(lèi)型的數(shù)組。例如：
Pair<String>[] table = new Pair<String>[10]; // 錯(cuò)誤
不能創(chuàng)建 Throwable 的子類(lèi)為泛型類(lèi)
如果希望創(chuàng)建一個(gè) Throwable 的子類(lèi)，那么子類(lèi)就不可以是泛型類(lèi)。例如：
class Generic<T> extends Exception {
}
此時(shí)，編譯器會(huì)直接報(bào)錯(cuò)，提示：Subclass of 'Throwable' may not have type parameters。
這還是因?yàn)榉盒筒脸?，這就導(dǎo)致在 catch 時(shí)不知道該執(zhí)行哪個(gè)代碼分支：
try {
...
} catch (Generic<String> e) {
} catch (Generic<Integer> e) {
}以上就是Java 泛型 Generic機(jī)制實(shí)例詳解的詳細(xì)內(nèi)容，更多關(guān)于Java 泛型 Generic的資料請(qǐng)關(guān)注腳本之家其它相關(guān)文章！
相關(guān)文章
Java中父類(lèi)和子類(lèi)之間的轉(zhuǎn)換操作示例
這篇文章主要介紹了Java中父類(lèi)和子類(lèi)之間的轉(zhuǎn)換操作,結(jié)合實(shí)例形式分析了Java中父類(lèi)和子類(lèi)之間的轉(zhuǎn)換相關(guān)原理、操作技巧與使用注意事項(xiàng),需要的朋友可以參考下2020-05-05
這篇文章主要介紹了flatten-maven-plugin使用，本文通過(guò)示例代碼給大家介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或工作具有一定的參考借鑒價(jià)值,需要的朋友可以參考下2023-07-07
Java中靜態(tài)代碼塊、構(gòu)造代碼塊、構(gòu)造函數(shù)和普通代碼塊的區(qū)別
在Java中，靜態(tài)代碼塊、構(gòu)造代碼塊、構(gòu)造函數(shù)、普通代碼塊的執(zhí)行順序是一個(gè)筆試的考點(diǎn)，通過(guò)這篇文章希望大家能徹底了解它們之間的執(zhí)行順序,需要的朋友可以參考下2023-05-05
在java中如何將inputStream對(duì)象轉(zhuǎn)換為File對(duì)象(不生成本地文件)
這篇文章主要介紹了在java中如何將inputStream對(duì)象轉(zhuǎn)換為File對(duì)象(不生成本地文件),具有很好的參考價(jià)值,希望對(duì)大家有所幫助,如有錯(cuò)誤或未考慮完全的地方,望不吝賜教2025-03-03
刪除List中元素這個(gè)場(chǎng)景很場(chǎng)景,很多人可能直接在循環(huán)中直接去刪除元素,這樣做對(duì)嗎？下面小編就來(lái)和大家一起討論如何正確遍歷刪除List中的元素,文中有詳細(xì)的代碼示例供大家參考,需要的朋友可以參考下2023-11-11
Spring中@ExceptionHandler注解的工作原理詳解
這篇文章主要介紹了Spring中@ExceptionHandler注解的工作原理詳解,Spring Web注解@ExceptionHandler可以用來(lái)指定處理某類(lèi)異常的控制器方法,從而在這些異常發(fā)生時(shí),會(huì)有相應(yīng)的控制器方法來(lái)處理此類(lèi)異常,需要的朋友可以參考下2024-01-01
詳解Java編程中Annotation注解對(duì)象的使用方法
這篇文章主要介紹了Java編程中Annotation注解對(duì)象的使用方法,注解以"@注解名"的方式被編寫(xiě),與類(lèi)、接口、枚舉是在同一個(gè)層次，需要的朋友可以參考下2016-03-03
這篇文章主要介紹了Java中final與繼承操作,結(jié)合實(shí)例形式分析了Java中使用final阻止繼承的相關(guān)原理與操作注意事項(xiàng),需要的朋友可以參考下2019-09-09
SpringBoot整合Security權(quán)限控制登錄首頁(yè)
這篇文章主要為大家介紹了SpringBoot整合Security權(quán)限控制登錄首頁(yè)示例，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加薪2022-11-11
java并發(fā)編程之進(jìn)程和線程調(diào)度基礎(chǔ)詳解
這篇文章主要介紹了java并發(fā)編程之進(jìn)程和線程調(diào)度基礎(chǔ)，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。如有錯(cuò)誤或未考慮完全的地方，望不吝賜教2023-06-06