java静态内部类
将某个内部类定义为静态类，跟将其他类定义为静态类的方法基本相同，引用规则也基本一致。不过其细节方面仍然有很大的不同。具体来说，主要有如下几个地方要引起各位程序开发人员的注意。
(一)一般情况下，如果一个内部类不是被定义成静态内部类，那么在定义成员变量或者成员方法的时候，是不能够被定义成静态成员变量与静态成员方法的。也就是说，在非静态内部类中不可以声明静态成员。
(二)一般非静态外部类可以随意访问其外部类的成员变量以及方法（包括声明为private的方法），但是如果一个内部类被声明为static，则其在访问包括自身的外部类会有诸多的限制。静态内部类不能访问其外部类的非静态成员变量和方法。
(三)在一个类中创建非静态成员内部类的时候，有一个强制性的规定，即内部类的实例一定要绑定在外部类的实例中。然后要在一个外部类中定义一个静态的内部类，不需要利用关键字new来创建内部类的实例。即在创建静态类内部对象时，不需要其外部类的对象。
java在实现linkedlist时使用了如下内部类：
我要评论
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同步工具类
/**
* 需要启动多个线程把接口数据分批导入目标，要求
* 每次执行的时候必须保证前一次任务已结束,处理这个需求的方式有很多种，其实质即
* 线程间同步问题，正好这两天我也在关注线程同步相关的东东，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) + "---" + "已被删除");
}
}
}
}
}
如对本文有疑问， 点击进行留言回复！！
荐 嵌入式linux开发环境搭建（Docker版，基于iTop 4412开发板）
SpringBoot项目部署到服务器之 Liunx环境安装jdk详细步骤
网友评论