java编写静态工具类_Java编程中静态内部类与同步类的写法示例

java静态内部类

将某个内部类定义为静态类，跟将其他类定义为静态类的方法基本相同，引用规则也基本一致。不过其细节方面仍然有很大的不同。具体来说，主要有如下几个地方要引起各位程序开发人员的注意。

(一)一般情况下，如果一个内部类不是被定义成静态内部类，那么在定义成员变量或者成员方法的时候，是不能够被定义成静态成员变量与静态成员方法的。也就是说，在非静态内部类中不可以声明静态成员。

(二)一般非静态外部类可以随意访问其外部类的成员变量以及方法(包括声明为private的方法)，但是如果一个内部类被声明为static，则其在访问包括自身的外部类会有诸多的限制。静态内部类不能访问其外部类的非静态成员变量和方法。

(三)在一个类中创建非静态成员内部类的时候，有一个强制性的规定，即内部类的实例一定要绑定在外部类的实例中。然后要在一个外部类中定义一个静态的内部类，不需要利用关键字new来创建内部类的实例。即在创建静态类内部对象时，不需要其外部类的对象。

java在实现LinkedList时使用了如下内部类：

public class LinkedList

extends AbstractSequentialList

implements List, Deque, Cloneable, java.io.Serializable

{

........

private static class Entry {

E element;

Entry next;

Entry previous;

Entry(E element, Entry next, Entry previous) {

this.element = element;

this.next = next;

this.previous = previous;

}

}

private Entry addBefore(E e, Entry entry) {

Entry newEntry = new Entry(e, entry, entry.previous);

newEntry.previous.next = newEntry;

newEntry.next.previous = newEntry;

size++;

modCount++;

return newEntry;

}

........

}

这里即静态内部类的典型用法

java同步工具类

/**

* 需要启动多个线程把接口数据分批导入目标，要求

* 每次执行的时候必须保证前一次任务已结束,处理这个需求的方式有很多种，其实质即

* 线程间同步问题，正好这两天我也在关注线程同步相关的东东，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 strList = null;

int k = 0;

static {

//模拟数据

strList = new ArrayList();

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) + "---" + "已被删除");

}

}

}

}

}