java静态内部类
将某个内部类定义为静态类，跟将其他类定义为静态类的方法基本相同，引用规则也基本一致。不过其细节方面仍然有很大的不同。具体来说，主要有如下几个地方要引起各位程序开发人员的注意。
(一)一般情况下，如果一个内部类不是被定义成静态内部类，那么在定义成员变量或者成员方法的时候，是不能够被定义成静态成员变量与静态成员方法的。也就是说，在非静态内部类中不可以声明静态成员。
(二)一般非静态外部类可以随意访问其外部类的成员变量以及方法（包括声明为private的方法），但是如果一个内部类被声明为static，则其在访问包括自身的外部类会有诸多的限制。静态内部类不能访问其外部类的非静态成员变量和方法。
(三)在一个类中创建非静态成员内部类的时候，有一个强制性的规定，即内部类的实例一定要绑定在外部类的实例中。然后要在一个外部类中定义一个静态的内部类，不需要利用关键字new来创建内部类的实例。即在创建静态类内部对象时，不需要其外部类的对象。
java在实现LinkedList时使用了如下内部类：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable { ........ private static class Entry<E> { E element; Entry<E> next; Entry<E> previous; Entry(E element, Entry<E> next, Entry<E> previous) { this.element = element; this.next = next; this.previous = previous; } } private Entry<E> addBefore(E e, Entry<E> entry) { Entry<E> newEntry = new Entry<E>(e, entry, entry.previous); newEntry.previous.next = newEntry; newEntry.next.previous = newEntry; size++; modCount++; return newEntry; } ........ } |
这里即静态内部类的典型用法
java同步工具类
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
|
/** * 需要启动多个线程把接口数据分批导入目标，要求 * 每次执行的时候必须保证前一次任务已结束,处理这个需求的方式有很多种，其实质即 * 线程间同步问题，正好这两天我也在关注线程同步相关的东东，jdk提供了不少的线程 * 同步工具类，CountDownLatch：一个同步辅助类，在完成一组正在其他线程中执行的 * 操作之前，它允许一个或多个线程一直等待。 * 用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前， * await 方法会一直受阻塞。之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。 * 这种现象只出现一次——计数无法被重置（这点很重要哦）。如果需要重置计数，请考虑使用 CyclicBarrier。 * 下面是一个简单的例子来模拟该需求，当然可能因为为了模拟场景，会有一些不合理的地方，这里主要阐述 * CountDownLatch同步,关于CountDownLatch的源码将在后面来分析，其主要涉及AbstractQueuedSynchronizer * 这个类，他的类容相对比较复杂 * **/ import java.util.ArrayList; import java.util.List; import java.util.Random; import java.util.concurrent.CountDownLatch; public class Driver { static List<Integer> strList = null; int k = 0; static { //模拟数据 strList = new ArrayList<Integer>(); for (int i = 0; i < 50; i++) { strList.add(i); } } public static void main(String args[]) { boolean isEnd = true; //为了验证正确性，只执行20次 int count=0; Driver d = new Driver(); while (isEnd && strList.size() > 0&&count<20) { CountDownLatch startSignal = new CountDownLatch(1); final CountDownLatch doneSignal = new CountDownLatch(5); for (int i = 0; i < 5; ++i) { new Thread(d.new Worker(startSignal, doneSignal,i)).start(); } //计数减1 子线程Worker可以执行 startSignal.countDown(); try { new Thread(new Runnable() { Random r = new Random(); @Override public void run() { try { //主线程阻塞 知道所有子线程将doneSignal清零 doneSignal.await(); } catch (InterruptedException e) { e.printStackTrace(); } while(strList.size()<=0){ int pos = r.nextInt(1000); strList.clear(); for (int i = pos; i < pos + 50; i++) { strList.add(i); } } } }).start(); isEnd = true; } catch (Exception e) { e.printStackTrace(); } count++; } } class Worker implements Runnable { private final CountDownLatch startSignal; private final CountDownLatch doneSignal; private int i; Worker(CountDownLatch startSignal, CountDownLatch doneSignal,int i) { this.startSignal = startSignal; this.doneSignal = doneSignal; this.i=i; } public void run() { try { // 等待主线程执行countDown startSignal.await(); doWork(); //计数减1 doneSignal.countDown(); } catch (InterruptedException ex) { } // return; } void doWork() { synchronized (strList) { int start=(i)*(50/5); int end=(i+1)*(50/5); for (int i = start; i < end; i++) { System.out.println(strList.get(i) + "---" + "已被删除"); } } } } } |
