Repository navigation
Expand file tree
/
Copy pathSolution.java
More file actions
167 lines (128 loc) · 6.57 KB
/
Copy pathSolution.java
File metadata and controls
167 lines (128 loc) · 6.57 KB
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
//And base things of the world, and things which are despised, has God chosen, yea, and things which are not,
//to bring to nothing things that are (1Cor 1:28)
--------------------------------------------------------Solution.java---------------------------------------------------------------
package com.javarush.task.task25.task2509;
import java.util.concurrent.*;
/*
Все не так легко, как кажется
*/
public class Solution extends ThreadPoolExecutor {
public Solution(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
}
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
if (callable instanceof CancellableTask) {
return ((CancellableTask<T>) callable).newTask();
} else {
return super.newTaskFor(callable);
}
}
public static void main(String[] args) {
}
}
------------------------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------SocketTask.java------------------------------------------------------------
package com.javarush.task.task25.task2509;
import java.net.Socket;
import java.util.concurrent.FutureTask;
import java.util.concurrent.RunnableFuture;
import java.io.IOException;
public abstract class SocketTask<T> implements CancellableTask<T> {
private Socket socket;
protected synchronized void setSocket(Socket socket) {
this.socket = socket;
}
public synchronized void cancel() {
try { //close all resources here
socket.close();
}catch (IOException ignored){ignored.printStackTrace();}
}
public RunnableFuture<T> newTask() {
return new FutureTask<T>(this) {
public boolean cancel(boolean mayInterruptIfRunning) {
//close all resources here by using proper SocketTask method
//call super-class method in finally block
try{
socket.close();
}catch (IOException ignored){ignored.printStackTrace();}
finally{super.cancel(mayInterruptIfRunning);}
return true;
}
};
}
}
------------------------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------CancellableTask.java-------------------------------------------------------
package com.javarush.task.task25.task2509;
import java.util.concurrent.Callable;
import java.util.concurrent.RunnableFuture;
public interface CancellableTask<T> extends Callable<T> {
void cancel();
RunnableFuture<T> newTask();
}
------------------------------------------------------------------------------------------------------------------------------------
/*
Все не так легко, как кажется
1. Почитать в инете про Socket, ThreadPoolExecutor, RunnableFuture, Callable.
2. Реализуй логику метода cancel в классе SocketTask.
3. Реализуй логику метода cancel для локального класса внутри метода newTask в классе SocketTask.
Требования:
1. Определение класса SocketTask, его поля и сигнатуры методов менять нельзя.
2. Метод cancel в классе SocketTask должен закрывать используемые классом ресурсы.
3. Метод cancel для локального класса внутри метода newTask должен закрывать ресурсы SocketTask и вызвать cancel у родительского класса.
4. Метод у родительского класса должен быть вызван, даже если во время закрытия ресурсов было выкинуто исключение.
--------------------------------------------------------Solution.java---------------------------------------------------------------
package com.javarush.task.task25.task2509;
import java.util.concurrent.*;
/*
Все не так легко, как кажется
*/
public class Solution extends ThreadPoolExecutor {
public Solution(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
}
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
if (callable instanceof CancellableTask) {
return ((CancellableTask<T>) callable).newTask();
} else {
return super.newTaskFor(callable);
}
}
public static void main(String[] args) {
}
}
------------------------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------SocketTask.java------------------------------------------------------------
package com.javarush.task.task25.task2509;
import java.net.Socket;
import java.util.concurrent.FutureTask;
import java.util.concurrent.RunnableFuture;
public abstract class SocketTask<T> implements CancellableTask<T> {
private Socket socket;
protected synchronized void setSocket(Socket socket) {
this.socket = socket;
}
public synchronized void cancel() {
//close all resources here
}
public RunnableFuture<T> newTask() {
return new FutureTask<T>(this) {
public boolean cancel(boolean mayInterruptIfRunning) {
//close all resources here by using proper SocketTask method
//call super-class method in finally block
return false;
}
};
}
}
------------------------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------CancellableTask.java-------------------------------------------------------
package com.javarush.task.task25.task2509;
import java.util.concurrent.Callable;
import java.util.concurrent.RunnableFuture;
public interface CancellableTask<T> extends Callable<T> {
void cancel();
RunnableFuture<T> newTask();
}
------------------------------------------------------------------------------------------------------------------------------------
*/