History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/com/sun/jmx/snmp/tasks/ThreadService.java (1 of 18352 files). Show all

Unified · Split

java/pkg/com/sun/jmx/snmp/tasks/ThreadService.java+246−0
@@ -0,0 +1,246 @@
1+/*
2+ * Copyright (c) 2002, 2008, Oracle and/or its affiliates. All rights reserved.
3+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4+ *
5+ * This code is free software; you can redistribute it and/or modify it
6+ * under the terms of the GNU General Public License version 2 only, as
7+ * published by the Free Software Foundation. Oracle designates this
8+ * particular file as subject to the "Classpath" exception as provided
9+ * by Oracle in the LICENSE file that accompanied this code.
10+ *
11+ * This code is distributed in the hope that it will be useful, but WITHOUT
12+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14+ * version 2 for more details (a copy is included in the LICENSE file that
15+ * accompanied this code).
16+ *
17+ * You should have received a copy of the GNU General Public License version
18+ * 2 along with this work; if not, write to the Free Software Foundation,
19+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20+ *
21+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22+ * or visit www.oracle.com if you need additional information or have any
23+ * questions.
24+ */
25+
26+package com.sun.jmx.snmp.tasks;
27+
28+import java.util.ArrayList;
29+import com.sun.jmx.snmp.tasks.Task;
30+import com.sun.jmx.snmp.tasks.TaskServer;
31+
32+/**
33+ * This class implements a {@link com.sun.jmx.snmp.tasks.TaskServer} over
34+ * a thread pool.
35+ * <p><b>This API is a Sun Microsystems internal API and is subject
36+ * to change without notice.</b></p>
37+ **/
38+public class ThreadService implements TaskServer {
39+
40+ public ThreadService(int threadNumber) {
41+ if (threadNumber <= 0) {
42+ throw new IllegalArgumentException("The thread number should bigger than zero.");
43+ }
44+
45+ minThreads = threadNumber;
46+ threadList = new ExecutorThread[threadNumber];
47+
48+ priority = Thread.currentThread().getPriority();
49+ cloader = Thread.currentThread().getContextClassLoader();
50+
51+ }
52+
53+// public methods
54+// --------------
55+
56+ /**
57+ * Submit a task to be executed.
58+ * Once a task is submitted, it is guaranteed that either
59+ * {@link com.sun.jmx.snmp.tasks.Task#run() task.run()} or
60+ * {@link com.sun.jmx.snmp.tasks.Task#cancel() task.cancel()} will be called.
61+ * This implementation of TaskServer uses a thread pool to execute
62+ * the submitted tasks.
63+ * @param task The task to be executed.
64+ * @exception IllegalArgumentException if the submitted task is null.
65+ **/
66+ public void submitTask(Task task) throws IllegalArgumentException {
67+ submitTask((Runnable)task);
68+ }
69+
70+ /**
71+ * Submit a task to be executed.
72+ * This implementation of TaskServer uses a thread pool to execute
73+ * the submitted tasks.
74+ * @param task The task to be executed.
75+ * @exception IllegalArgumentException if the submitted task is null.
76+ **/
77+ public void submitTask(Runnable task) throws IllegalArgumentException {
78+ stateCheck();
79+
80+ if (task == null) {
81+ throw new IllegalArgumentException("No task specified.");
82+ }
83+
84+ synchronized(jobList) {
85+ jobList.add(jobList.size(), task);
86+
87+ jobList.notify();
88+ }
89+
90+ createThread();
91+ }
92+
93+ public Runnable removeTask(Runnable task) {
94+ stateCheck();
95+
96+ Runnable removed = null;
97+ synchronized(jobList) {
98+ int lg = jobList.indexOf(task);
99+ if (lg >= 0) {
100+ removed = jobList.remove(lg);
101+ }
102+ }
103+ if (removed != null && removed instanceof Task)
104+ ((Task) removed).cancel();
105+ return removed;
106+ }
107+
108+ public void removeAll() {
109+ stateCheck();
110+
111+ final Object[] jobs;
112+ synchronized(jobList) {
113+ jobs = jobList.toArray();
114+ jobList.clear();
115+ }
116+ final int len = jobs.length;
117+ for (int i=0; i<len ; i++) {
118+ final Object o = jobs[i];
119+ if (o!= null && o instanceof Task) ((Task)o).cancel();
120+ }
121+ }
122+
123+ // to terminate
124+ public void terminate() {
125+
126+ if (terminated == true) {
127+ return;
128+ }
129+
130+ terminated = true;
131+
132+ synchronized(jobList) {
133+ jobList.notifyAll();
134+ }
135+
136+ removeAll();
137+
138+ for (int i=0; i<currThreds; i++) {
139+ try {
140+ threadList[i].interrupt();
141+ } catch (Exception e) {
142+ // TODO
143+ }
144+ }
145+
146+ threadList = null;
147+ }
148+
149+// private classes
150+// ---------------
151+
152+ // A thread used to execute jobs
153+ //
154+ private class ExecutorThread extends Thread {
155+ public ExecutorThread() {
156+ super(threadGroup, "ThreadService-"+counter++);
157+ setDaemon(true);
158+
159+ // init
160+ this.setPriority(priority);
161+ this.setContextClassLoader(cloader);
162+
163+ idle++;
164+ }
165+
166+ public void run() {
167+
168+ while(!terminated) {
169+ Runnable job = null;
170+
171+ synchronized(jobList) {
172+ if (jobList.size() > 0) {
173+ job = jobList.remove(0);
174+ if (jobList.size() > 0) {
175+ jobList.notify();
176+ }
177+
178+ } else {
179+ try {
180+ jobList.wait();
181+ } catch (InterruptedException ie) {
182+ // terminated ?
183+ } finally {
184+ }
185+ continue;
186+ }
187+ }
188+ if (job != null) {
189+ try {
190+ idle--;
191+ job.run();
192+ } catch (Exception e) {
193+ // TODO
194+ e.printStackTrace();
195+ } finally {
196+ idle++;
197+ }
198+ }
199+
200+ // re-init
201+ this.setPriority(priority);
202+ this.interrupted();
203+ this.setContextClassLoader(cloader);
204+ }
205+ }
206+ }
207+
208+// private methods
209+ private void stateCheck() throws IllegalStateException {
210+ if (terminated) {
211+ throw new IllegalStateException("The thread service has been terminated.");
212+ }
213+ }
214+
215+ private void createThread() {
216+ if (idle < 1) {
217+ synchronized(threadList) {
218+ if (jobList.size() > 0 && currThreds < minThreads) {
219+ ExecutorThread et = new ExecutorThread();
220+ et.start();
221+ threadList[currThreds++] = et;
222+ }
223+ }
224+ }
225+ }
226+
227+
228+// protected or private variables
229+// ------------------------------
230+ private ArrayList<Runnable> jobList = new ArrayList<Runnable>(0);
231+
232+ private ExecutorThread[] threadList;
233+ private int minThreads = 1;
234+ private int currThreds = 0;
235+ private int idle = 0;
236+
237+ private boolean terminated = false;
238+ private int priority;
239+ private ThreadGroup threadGroup = new ThreadGroup("ThreadService");
240+ private ClassLoader cloader;
241+
242+ private static long counter = 0;
243+
244+ private int addedJobs = 1;
245+ private int doneJobs = 1;
246+}