Java编程中静态内部类与同步类的写法示例
java静态内部类
将某个内部类定义为静态类，跟将其他类定义为静态类的方法基本相同，引用规则也基本一致。不过其细节方面仍然有很大的不同。具体来说，主要有如下几个地方要引起各位程序开发人员的注意。
(一)一般情况下，如果一个内部类不是被定义成静态内部类，那么在定义成员变量或者成员方法的时候，是不能够被定义成静态成员变量与静态成员方法的。也就是说，在非静态内部类中不可以声明静态成员。
(二)一般非静态外部类可以随意访问其外部类的成员变量以及方法（包括声明为private的方法），但是如果一个内部类被声明为static，则其在访问包括自身的外部类会有诸多的限制。静态内部类不能访问其外部类的非静态成员变量和方法。
(三)在一个类中创建非静态成员内部类的时候，有一个强制性的规定，即内部类的实例一定要绑定在外部类的实例中。然后要在一个外部类中定义一个静态的内部类，不需要利用关键字new来创建内部类的实例。即在创建静态类内部对象时，不需要其外部类的对象。
java在实现LinkedList时使用了如下内部类：
publicclassLinkedList<E>
extendsAbstractSequentialList<E>
implementsList<E>,Deque<E>,Cloneable,java.io.Serializable
{
........
privatestaticclassEntry<E>{
Eelement;
Entry<E>next;
Entry<E>previous;
Entry(Eelement,Entry<E>next,Entry<E>previous){
this.element=element;
this.next=next;
this.previous=previous;
}
}
privateEntry<E>addBefore(Ee,Entry<E>entry){
Entry<E>newEntry=newEntry<E>(e,entry,entry.previous);
newEntry.previous.next=newEntry;
newEntry.next.previous=newEntry;
size++;
modCount++;
returnnewEntry;
}
........
}
这里即静态内部类的典型用法
java同步工具类
/**
*需要启动多个线程把接口数据分批导入目标，要求
*每次执行的时候必须保证前一次任务已结束,处理这个需求的方式有很多种，其实质即
*线程间同步问题，正好这两天我也在关注线程同步相关的东东，jdk提供了不少的线程
*同步工具类，CountDownLatch：一个同步辅助类，在完成一组正在其他线程中执行的
*操作之前，它允许一个或多个线程一直等待。
*用给定的计数初始化CountDownLatch。由于调用了countDown()方法，所以在当前计数到达零之前，
*await方法会一直受阻塞。之后，会释放所有等待的线程，await的所有后续调用都将立即返回。
*这种现象只出现一次——计数无法被重置（这点很重要哦）。如果需要重置计数，请考虑使用CyclicBarrier。
*下面是一个简单的例子来模拟该需求，当然可能因为为了模拟场景，会有一些不合理的地方，这里主要阐述
*CountDownLatch同步,关于CountDownLatch的源码将在后面来分析，其主要涉及AbstractQueuedSynchronizer
*这个类，他的类容相对比较复杂
***/
importjava.util.ArrayList;
importjava.util.List;
importjava.util.Random;
importjava.util.concurrent.CountDownLatch;
publicclassDriver{
staticList<Integer>strList=null;
intk=0;
static{
//模拟数据
strList=newArrayList<Integer>();
for(inti=0;i<50;i++){
strList.add(i);
}
}
publicstaticvoidmain(Stringargs[]){
booleanisEnd=true;
//为了验证正确性，只执行20次
intcount=0;
Driverd=newDriver();
while(isEnd&&strList.size()>0&&count<20){
CountDownLatchstartSignal=newCountDownLatch(1);
finalCountDownLatchdoneSignal=newCountDownLatch(5);
for(inti=0;i<5;++i)
{
newThread(d.newWorker(startSignal,doneSignal,i)).start();
}
//计数减1子线程Worker可以执行
startSignal.countDown();
try{
newThread(newRunnable(){
Randomr=newRandom();
@Override
publicvoidrun(){
try{
//主线程阻塞知道所有子线程将doneSignal清零
doneSignal.await();
}catch(InterruptedExceptione){
e.printStackTrace();
}
while(strList.size()<=0){
intpos=r.nextInt(1000);
strList.clear();
for(inti=pos;i<pos+50;i++){
strList.add(i);
}
}
}
}).start();
isEnd=true;
}catch(Exceptione){
e.printStackTrace();
}
count++;
}
}
classWorkerimplementsRunnable{
privatefinalCountDownLatchstartSignal;
privatefinalCountDownLatchdoneSignal;
privateinti;
Worker(CountDownLatchstartSignal,CountDownLatchdoneSignal,inti){
this.startSignal=startSignal;
this.doneSignal=doneSignal;
this.i=i;
}
publicvoidrun(){
try{
//等待主线程执行countDown
startSignal.await();
doWork();
//计数减1
doneSignal.countDown();
}catch(InterruptedExceptionex){
}//return;
}
voiddoWork(){
synchronized(strList){
intstart=(i)*(50/5);
intend=(i+1)*(50/5);
for(inti=start;i<end;i++){
System.out.println(strList.get(i)+"---"+"已被删除");
}
}
}
}
}