Schisandra-Cloud-Storage/schisandra-cloud-storage
5
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat: add asyncTool

Browse Source
This commit is contained in:
landaiqing
2024-06-25 21:08:44 +08:00
parent a64b1f9533
commit ae608c5cf2
42 changed files with 3299 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
schisandra-cloud-storage-asyncTool/src/test/java/depend/DeWorker.java Normal file
View File

@@ -0,0 +1,42 @@
package depend;
import com.jd.platform.async.callback.ICallback;
import com.jd.platform.async.callback.IWorker;
import com.jd.platform.async.worker.WorkResult;
import com.jd.platform.async.wrapper.WorkerWrapper;
import java.util.Map;
/**
* @author wuweifeng wrote on 2019-11-20.
*/
public class DeWorker implements IWorker<String, User>, ICallback<String, User> {
@Override
public User action(String object, Map<String, WorkerWrapper> allWrappers) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return new User("user0");
}
@Override
public User defaultValue() {
return new User("default User");
}
@Override
public void begin() {
//System.out.println(Thread.currentThread().getName() + "- start --" + System.currentTimeMillis());
}
@Override
public void result(boolean success, String param, WorkResult<User> workResult) {
System.out.println("worker0 的结果是：" + workResult.getResult());
}
}

43
schisandra-cloud-storage-asyncTool/src/test/java/depend/DeWorker1.java Normal file
View File

@@ -0,0 +1,43 @@
package depend;
import com.jd.platform.async.callback.ICallback;
import com.jd.platform.async.callback.IWorker;
import com.jd.platform.async.worker.WorkResult;
import com.jd.platform.async.wrapper.WorkerWrapper;
import java.util.Map;
/**
* @author wuweifeng wrote on 2019-11-20.
*/
public class DeWorker1 implements IWorker<WorkResult<User>, User>, ICallback<WorkResult<User>, User> {
@Override
public User action(WorkResult<User> result, Map<String, WorkerWrapper> allWrappers) {
System.out.println("par1的入参来自于par0： " + result.getResult());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return new User("user1");
}
@Override
public User defaultValue() {
return new User("default User");
}
@Override
public void begin() {
//System.out.println(Thread.currentThread().getName() + "- start --" + System.currentTimeMillis());
}
@Override
public void result(boolean success, WorkResult<User> param, WorkResult<User> workResult) {
System.out.println("worker1 的结果是：" + workResult.getResult());
}
}

43
schisandra-cloud-storage-asyncTool/src/test/java/depend/DeWorker2.java Normal file
View File

@@ -0,0 +1,43 @@
package depend;
import com.jd.platform.async.callback.ICallback;
import com.jd.platform.async.callback.IWorker;
import com.jd.platform.async.worker.WorkResult;
import com.jd.platform.async.wrapper.WorkerWrapper;
import java.util.Map;
/**
* @author wuweifeng wrote on 2019-11-20.
*/
public class DeWorker2 implements IWorker<WorkResult<User>, String>, ICallback<WorkResult<User>, String> {
@Override
public String action(WorkResult<User> result, Map<String, WorkerWrapper> allWrappers) {
System.out.println("par2的入参来自于par1： " + result.getResult());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return result.getResult().getName();
}
@Override
public String defaultValue() {
return "default";
}
@Override
public void begin() {
//System.out.println(Thread.currentThread().getName() + "- start --" + System.currentTimeMillis());
}
@Override
public void result(boolean success, WorkResult<User> param, WorkResult<String> workResult) {
System.out.println("worker2 的结果是：" + workResult.getResult());
}
}

74
schisandra-cloud-storage-asyncTool/src/test/java/depend/LambdaTest.java Normal file
View File

@@ -0,0 +1,74 @@
package depend;
import java.util.Map;
import com.jd.platform.async.executor.Async;
import com.jd.platform.async.worker.WorkResult;
import com.jd.platform.async.wrapper.WorkerWrapper;
/**
* @author sjsdfg
* @since 2020/6/14
*/
public class LambdaTest {
public static void main(String[] args) throws Exception {
WorkerWrapper<WorkResult<User>, String> workerWrapper2 = new WorkerWrapper.Builder<WorkResult<User>, String>()
.worker((WorkResult<User> result, Map<String, WorkerWrapper> allWrappers) -> {
System.out.println("par2的入参来自于par1： " + result.getResult());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return result.getResult().getName();
})
.callback((boolean success, WorkResult<User> param, WorkResult<String> workResult) ->
System.out.println(String.format("thread is %s, param is %s, result is %s", Thread.currentThread().getName(), param, workResult)))
.id("third")
.build();
WorkerWrapper<WorkResult<User>, User> workerWrapper1 = new WorkerWrapper.Builder<WorkResult<User>, User>()
.worker((WorkResult<User> result, Map<String, WorkerWrapper> allWrappers) -> {
System.out.println("par1的入参来自于par0： " + result.getResult());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return new User("user1");
})
.callback((boolean success, WorkResult<User> param, WorkResult<User> workResult) ->
System.out.println(String.format("thread is %s, param is %s, result is %s", Thread.currentThread().getName(), param, workResult)))
.id("second")
.next(workerWrapper2)
.build();
WorkerWrapper<String, User> workerWrapper = new WorkerWrapper.Builder<String, User>()
.worker((String object, Map<String, WorkerWrapper> allWrappers) -> {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return new User("user0");
})
.param("0")
.id("first")
.next(workerWrapper1, true)
.callback((boolean success, String param, WorkResult<User> workResult) ->
System.out.println(String.format("thread is %s, param is %s, result is %s", Thread.currentThread().getName(), param, workResult)))
.build();
//虽然尚未执行，但是也可以先取得结果的引用，作为下一个任务的入参。V1.2前写法，需要手工给
//V1.3后，不用给wrapper setParam了，直接在worker的action里自行根据id获取即可.参考dependnew包下代码
WorkResult<User> result = workerWrapper.getWorkResult();
WorkResult<User> result1 = workerWrapper1.getWorkResult();
workerWrapper1.setParam(result);
workerWrapper2.setParam(result1);
Async.beginWork(3500, workerWrapper);
System.out.println(workerWrapper2.getWorkResult());
Async.shutDown();
}
}

55
schisandra-cloud-storage-asyncTool/src/test/java/depend/Test.java Normal file
View File

@@ -0,0 +1,55 @@
package depend;
import com.jd.platform.async.executor.Async;
import com.jd.platform.async.worker.WorkResult;
import com.jd.platform.async.wrapper.WorkerWrapper;
import java.util.concurrent.ExecutionException;
/**
* 后面请求依赖于前面请求的执行结果
* @author wuweifeng wrote on 2019-12-26
* @version 1.0
*/
public class Test {
public static void main(String[] args) throws ExecutionException, InterruptedException {
DeWorker w = new DeWorker();
DeWorker1 w1 = new DeWorker1();
DeWorker2 w2 = new DeWorker2();
WorkerWrapper<WorkResult<User>, String> workerWrapper2 = new WorkerWrapper.Builder<WorkResult<User>, String>()
.worker(w2)
.callback(w2)
.id("third")
.build();
WorkerWrapper<WorkResult<User>, User> workerWrapper1 = new WorkerWrapper.Builder<WorkResult<User>, User>()
.worker(w1)
.callback(w1)
.id("second")
.next(workerWrapper2)
.build();
WorkerWrapper<String, User> workerWrapper = new WorkerWrapper.Builder<String, User>()
.worker(w)
.param("0")
.id("first")
.next(workerWrapper1, true)
.callback(w)
.build();
//虽然尚未执行，但是也可以先取得结果的引用，作为下一个任务的入参。V1.2前写法，需要手工给
//V1.3后，不用给wrapper setParam了，直接在worker的action里自行根据id获取即可.参考dependnew包下代码
WorkResult<User> result = workerWrapper.getWorkResult();
WorkResult<User> result1 = workerWrapper1.getWorkResult();
workerWrapper1.setParam(result);
workerWrapper2.setParam(result1);
Async.beginWork(3500, workerWrapper);
System.out.println(workerWrapper2.getWorkResult());
Async.shutDown();
}
}

29
schisandra-cloud-storage-asyncTool/src/test/java/depend/User.java Normal file
View File

@@ -0,0 +1,29 @@
package depend;
/**
* 一个包装类
* @author wuweifeng wrote on 2019-12-26
* @version 1.0
*/
public class User {
private String name;
public User(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}

42
schisandra-cloud-storage-asyncTool/src/test/java/dependnew/DeWorker.java Normal file
View File

@@ -0,0 +1,42 @@
package dependnew;
import com.jd.platform.async.callback.ICallback;
import com.jd.platform.async.callback.IWorker;
import com.jd.platform.async.worker.WorkResult;
import com.jd.platform.async.wrapper.WorkerWrapper;
import java.util.Map;
/**
* @author wuweifeng wrote on 2019-11-20.
*/
public class DeWorker implements IWorker<String, User>, ICallback<String, User> {
@Override
public User action(String object, Map<String, WorkerWrapper> allWrappers) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return new User("user0");
}
@Override
public User defaultValue() {
return new User("default User");
}
@Override
public void begin() {
//System.out.println(Thread.currentThread().getName() + "- start --" + System.currentTimeMillis());
}
@Override
public void result(boolean success, String param, WorkResult<User> workResult) {
System.out.println("worker0 的结果是：" + workResult.getResult());
}
}

45
schisandra-cloud-storage-asyncTool/src/test/java/dependnew/DeWorker1.java Normal file
View File

@@ -0,0 +1,45 @@
package dependnew;
import com.jd.platform.async.callback.ICallback;
import com.jd.platform.async.callback.IWorker;
import com.jd.platform.async.worker.WorkResult;
import com.jd.platform.async.wrapper.WorkerWrapper;
import java.util.Map;
/**
* @author wuweifeng wrote on 2019-11-20.
*/
public class DeWorker1 implements IWorker<String, User>, ICallback<String, User> {
@Override
public User action(String object, Map<String, WorkerWrapper> allWrappers) {
System.out.println("-----------------");
System.out.println("获取par0的执行结果： " + allWrappers.get("first").getWorkResult());
System.out.println("取par0的结果作为自己的入参，并将par0的结果加上一些东西");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
User user0 = (User) allWrappers.get("first").getWorkResult().getResult();
return new User(user0.getName() + " worker1 add");
}
@Override
public User defaultValue() {
return new User("default User");
}
@Override
public void begin() {
//System.out.println(Thread.currentThread().getName() + "- start --" + System.currentTimeMillis());
}
@Override
public void result(boolean success, String param, WorkResult<User> workResult) {
System.out.println("worker1 的结果是：" + workResult.getResult());
}
}

45
schisandra-cloud-storage-asyncTool/src/test/java/dependnew/DeWorker2.java Normal file
View File

@@ -0,0 +1,45 @@
package dependnew;
import com.jd.platform.async.callback.ICallback;
import com.jd.platform.async.callback.IWorker;
import com.jd.platform.async.worker.WorkResult;
import com.jd.platform.async.wrapper.WorkerWrapper;
import java.util.Map;
/**
* @author wuweifeng wrote on 2019-11-20.
*/
public class DeWorker2 implements IWorker<User, String>, ICallback<User, String> {
@Override
public String action(User object, Map<String, WorkerWrapper> allWrappers) {
System.out.println("-----------------");
System.out.println("par1的执行结果是： " + allWrappers.get("second").getWorkResult());
System.out.println("取par1的结果作为自己的入参，并将par1的结果加上一些东西");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
User user1 = (User) allWrappers.get("second").getWorkResult().getResult();
return user1.getName() + " worker2 add";
}
@Override
public String defaultValue() {
return "default";
}
@Override
public void begin() {
//System.out.println(Thread.currentThread().getName() + "- start --" + System.currentTimeMillis());
}
@Override
public void result(boolean success, User param, WorkResult<String> workResult) {
System.out.println("worker2 的结果是：" + workResult.getResult());
}
}

49
schisandra-cloud-storage-asyncTool/src/test/java/dependnew/Test.java Normal file
View File

@@ -0,0 +1,49 @@
package dependnew;
import com.jd.platform.async.executor.Async;
import com.jd.platform.async.wrapper.WorkerWrapper;
import java.util.concurrent.ExecutionException;
/**
* 后面请求依赖于前面请求的执行结果
* @author wuweifeng wrote on 2019-12-26
* @version 1.0
*/
public class Test {
public static void main(String[] args) throws ExecutionException, InterruptedException {
DeWorker w = new DeWorker();
DeWorker1 w1 = new DeWorker1();
DeWorker2 w2 = new DeWorker2();
WorkerWrapper<User, String> workerWrapper2 = new WorkerWrapper.Builder<User, String>()
.worker(w2)
.callback(w2)
.id("third")
.build();
WorkerWrapper<String, User> workerWrapper1 = new WorkerWrapper.Builder<String, User>()
.worker(w1)
.callback(w1)
.id("second")
.next(workerWrapper2)
.build();
WorkerWrapper<String, User> workerWrapper = new WorkerWrapper.Builder<String, User>()
.worker(w)
.param("0")
.id("first")
.next(workerWrapper1)
.callback(w)
.build();
//V1.3后，不用给wrapper setParam了，直接在worker的action里自行根据id获取即可
Async.beginWork(3500, workerWrapper);
System.out.println(workerWrapper2.getWorkResult());
Async.shutDown();
}
}

29
schisandra-cloud-storage-asyncTool/src/test/java/dependnew/User.java Normal file
View File

@@ -0,0 +1,29 @@
package dependnew;
/**
* 一个包装类
* @author wuweifeng wrote on 2019-12-26
* @version 1.0
*/
public class User {
private String name;
public User(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}

49
schisandra-cloud-storage-asyncTool/src/test/java/parallel/ParTimeoutWorker.java Normal file
View File

@@ -0,0 +1,49 @@
package parallel;
import com.jd.platform.async.callback.ICallback;
import com.jd.platform.async.callback.IWorker;
import com.jd.platform.async.executor.timer.SystemClock;
import com.jd.platform.async.worker.WorkResult;
import com.jd.platform.async.wrapper.WorkerWrapper;
import java.util.Map;
/**
* @author wuweifeng wrote on 2019-11-20.
*/
public class ParTimeoutWorker implements IWorker<String, String>, ICallback<String, String> {
@Override
public String action(String object, Map<String, WorkerWrapper> allWrappers) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "result = " + SystemClock.now() + "---param = " + object + " from 0";
}
@Override
public String defaultValue() {
return "worker0--default";
}
@Override
public void begin() {
//System.out.println(Thread.currentThread().getName() + "- start --" + System.currentTimeMillis());
}
@Override
public void result(boolean success, String param, WorkResult<String> workResult) {
if (success) {
System.out.println("callback worker0 success--" + SystemClock.now() + "----" + workResult.getResult()
+ "-threadName:" +Thread.currentThread().getName());
} else {
System.err.println("callback worker0 failure--" + SystemClock.now() + "----" + workResult.getResult()
+ "-threadName:" +Thread.currentThread().getName());
}
}
}

49
schisandra-cloud-storage-asyncTool/src/test/java/parallel/ParWorker.java Normal file
View File

@@ -0,0 +1,49 @@
package parallel;
import com.jd.platform.async.callback.ICallback;
import com.jd.platform.async.callback.IWorker;
import com.jd.platform.async.executor.timer.SystemClock;
import com.jd.platform.async.worker.WorkResult;
import com.jd.platform.async.wrapper.WorkerWrapper;
import java.util.Map;
/**
* @author wuweifeng wrote on 2019-11-20.
*/
public class ParWorker implements IWorker<String, String>, ICallback<String, String> {
@Override
public String action(String object, Map<String, WorkerWrapper> allWrappers) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "result = " + SystemClock.now() + "---param = " + object + " from 0";
}
@Override
public String defaultValue() {
return "worker0--default";
}
@Override
public void begin() {
//System.out.println(Thread.currentThread().getName() + "- start --" + System.currentTimeMillis());
}
@Override
public void result(boolean success, String param, WorkResult<String> workResult) {
if (success) {
System.out.println("callback worker0 success--" + SystemClock.now() + "----" + workResult.getResult()
+ "-threadName:" +Thread.currentThread().getName());
} else {
System.err.println("callback worker0 failure--" + SystemClock.now() + "----" + workResult.getResult()
+ "-threadName:" +Thread.currentThread().getName());
}
}
}

53
schisandra-cloud-storage-asyncTool/src/test/java/parallel/ParWorker1.java Normal file
View File

@@ -0,0 +1,53 @@
package parallel;
import com.jd.platform.async.callback.ICallback;
import com.jd.platform.async.callback.IWorker;
import com.jd.platform.async.executor.timer.SystemClock;
import com.jd.platform.async.worker.WorkResult;
import com.jd.platform.async.wrapper.WorkerWrapper;
import java.util.Map;
/**
* @author wuweifeng wrote on 2019-11-20.
*/
public class ParWorker1 implements IWorker<String, String>, ICallback<String, String> {
private long sleepTime = 1000;
public void setSleepTime(long sleepTime) {
this.sleepTime = sleepTime;
}
@Override
public String action(String object, Map<String, WorkerWrapper> allWrappers) {
try {
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "result = " + SystemClock.now() + "---param = " + object + " from 1";
}
@Override
public String defaultValue() {
return "worker1--default";
}
@Override
public void begin() {
//System.out.println(Thread.currentThread().getName() + "- start --" + System.currentTimeMillis());
}
@Override
public void result(boolean success, String param, WorkResult<String> workResult) {
if (success) {
System.out.println("callback worker1 success--" + SystemClock.now() + "----" + workResult.getResult()
+ "-threadName:" +Thread.currentThread().getName());
} else {
System.err.println("callback worker1 failure--" + SystemClock.now() + "----" + workResult.getResult()
+ "-threadName:" +Thread.currentThread().getName());
}
}
}

54
schisandra-cloud-storage-asyncTool/src/test/java/parallel/ParWorker2.java Normal file
View File

@@ -0,0 +1,54 @@
package parallel;
import com.jd.platform.async.callback.ICallback;
import com.jd.platform.async.callback.IWorker;
import com.jd.platform.async.executor.timer.SystemClock;
import com.jd.platform.async.worker.WorkResult;
import com.jd.platform.async.wrapper.WorkerWrapper;
import java.util.Map;
/**
* @author wuweifeng wrote on 2019-11-20.
*/
public class ParWorker2 implements IWorker<String, String>, ICallback<String, String> {
private long sleepTime = 1000;
public void setSleepTime(long sleepTime) {
this.sleepTime = sleepTime;
}
@Override
public String action(String object, Map<String, WorkerWrapper> allWrappers) {
try {
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "result = " + SystemClock.now() + "---param = " + object + " from 2";
}
@Override
public String defaultValue() {
return "worker2--default";
}
@Override
public void begin() {
//System.out.println(Thread.currentThread().getName() + "- start --" + System.currentTimeMillis());
}
@Override
public void result(boolean success, String param, WorkResult<String> workResult) {
if (success) {
System.out.println("callback worker2 success--" + SystemClock.now() + "----" + workResult.getResult()
+ "-threadName:" +Thread.currentThread().getName());
} else {
System.err.println("callback worker2 failure--" + SystemClock.now() + "----" + workResult.getResult()
+ "-threadName:" +Thread.currentThread().getName());
}
}
}

53
schisandra-cloud-storage-asyncTool/src/test/java/parallel/ParWorker3.java Normal file
View File

@@ -0,0 +1,53 @@
package parallel;
import com.jd.platform.async.callback.ICallback;
import com.jd.platform.async.callback.IWorker;
import com.jd.platform.async.executor.timer.SystemClock;
import com.jd.platform.async.worker.WorkResult;
import com.jd.platform.async.wrapper.WorkerWrapper;
import java.util.Map;
/**
* @author wuweifeng wrote on 2019-11-20.
*/
public class ParWorker3 implements IWorker<String, String>, ICallback<String, String> {
private long sleepTime = 1000;
public void setSleepTime(long sleepTime) {
this.sleepTime = sleepTime;
}
@Override
public String action(String object, Map<String, WorkerWrapper> allWrappers) {
try {
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "result = " + SystemClock.now() + "---param = " + object + " from 3";
}
@Override
public String defaultValue() {
return "worker3--default";
}
@Override
public void begin() {
//System.out.println(Thread.currentThread().getName() + "- start --" + System.currentTimeMillis());
}
@Override
public void result(boolean success, String param, WorkResult<String> workResult) {
if (success) {
System.out.println("callback worker3 success--" + SystemClock.now() + "----" + workResult.getResult()
+ "-threadName:" +Thread.currentThread().getName());
} else {
System.err.println("callback worker3 failure--" + SystemClock.now() + "----" + workResult.getResult()
+ "-threadName:" +Thread.currentThread().getName());
}
}
}

49
schisandra-cloud-storage-asyncTool/src/test/java/parallel/ParWorker4.java Normal file
View File

@@ -0,0 +1,49 @@
package parallel;
import com.jd.platform.async.callback.ICallback;
import com.jd.platform.async.callback.IWorker;
import com.jd.platform.async.executor.timer.SystemClock;
import com.jd.platform.async.worker.WorkResult;
import com.jd.platform.async.wrapper.WorkerWrapper;
import java.util.Map;
/**
* @author wuweifeng wrote on 2019-11-20.
*/
public class ParWorker4 implements IWorker<String, String>, ICallback<String, String> {
@Override
public String action(String object, Map<String, WorkerWrapper> allWrappers) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "result = " + SystemClock.now() + "---param = " + object + " from 4";
}
@Override
public String defaultValue() {
return "worker4--default";
}
@Override
public void begin() {
//System.out.println(Thread.currentThread().getName() + "- start --" + System.currentTimeMillis());
}
@Override
public void result(boolean success, String param, WorkResult<String> workResult) {
if (success) {
System.out.println("callback worker4 success--" + SystemClock.now() + "----" + workResult.getResult()
+ "-threadName:" +Thread.currentThread().getName());
} else {
System.err.println("callback worker4 failure--" + SystemClock.now() + "----" + workResult.getResult()
+ "-threadName:" +Thread.currentThread().getName());
}
}
}

53
schisandra-cloud-storage-asyncTool/src/test/java/parallel/ParWorker5.java Normal file
View File

@@ -0,0 +1,53 @@
package parallel;
import com.jd.platform.async.callback.ICallback;
import com.jd.platform.async.callback.IWorker;
import com.jd.platform.async.executor.timer.SystemClock;
import com.jd.platform.async.worker.WorkResult;
import com.jd.platform.async.wrapper.WorkerWrapper;
import java.util.Map;
/**
* @author wuweifeng wrote on 2019-11-20.
*/
public class ParWorker5 implements IWorker<String, String>, ICallback<String, String> {
private long sleepTime = 1000;
public void setSleepTime(long sleepTime) {
this.sleepTime = sleepTime;
}
@Override
public String action(String object, Map<String, WorkerWrapper> allWrappers) {
try {
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "result = " + SystemClock.now() + "---param = " + object + " from 3";
}
@Override
public String defaultValue() {
return "worker3--default";
}
@Override
public void begin() {
//System.out.println(Thread.currentThread().getName() + "- start --" + System.currentTimeMillis());
}
@Override
public void result(boolean success, String param, WorkResult<String> workResult) {
if (success) {
System.out.println("callback worker3 success--" + SystemClock.now() + "----" + workResult.getResult()
+ "-threadName:" +Thread.currentThread().getName());
} else {
System.err.println("callback worker3 failure--" + SystemClock.now() + "----" + workResult.getResult()
+ "-threadName:" +Thread.currentThread().getName());
}
}
}

53
schisandra-cloud-storage-asyncTool/src/test/java/parallel/ParWorker6.java Normal file
View File

@@ -0,0 +1,53 @@
package parallel;
import com.jd.platform.async.callback.ICallback;
import com.jd.platform.async.callback.IWorker;
import com.jd.platform.async.executor.timer.SystemClock;
import com.jd.platform.async.worker.WorkResult;
import com.jd.platform.async.wrapper.WorkerWrapper;
import java.util.Map;
/**
* @author wuweifeng wrote on 2019-11-20.
*/
public class ParWorker6 implements IWorker<String, String>, ICallback<String, String> {
private long sleepTime = 1000;
public void setSleepTime(long sleepTime) {
this.sleepTime = sleepTime;
}
@Override
public String action(String object, Map<String, WorkerWrapper> allWrappers) {
try {
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "result = " + SystemClock.now() + "---param = " + object + " from 3";
}
@Override
public String defaultValue() {
return "worker3--default";
}
@Override
public void begin() {
//System.out.println(Thread.currentThread().getName() + "- start --" + System.currentTimeMillis());
}
@Override
public void result(boolean success, String param, WorkResult<String> workResult) {
if (success) {
System.out.println("callback worker3 success--" + SystemClock.now() + "----" + workResult.getResult()
+ "-threadName:" +Thread.currentThread().getName());
} else {
System.err.println("callback worker3 failure--" + SystemClock.now() + "----" + workResult.getResult()
+ "-threadName:" +Thread.currentThread().getName());
}
}
}

53
schisandra-cloud-storage-asyncTool/src/test/java/parallel/ParWorker7.java Normal file
View File

@@ -0,0 +1,53 @@
package parallel;
import com.jd.platform.async.callback.ICallback;
import com.jd.platform.async.callback.IWorker;
import com.jd.platform.async.executor.timer.SystemClock;
import com.jd.platform.async.worker.WorkResult;
import com.jd.platform.async.wrapper.WorkerWrapper;
import java.util.Map;
/**
* @author wuweifeng wrote on 2019-11-20.
*/
public class ParWorker7 implements IWorker<String, String>, ICallback<String, String> {
private long sleepTime = 1000;
public void setSleepTime(long sleepTime) {
this.sleepTime = sleepTime;
}
@Override
public String action(String object, Map<String, WorkerWrapper> allWrappers) {
try {
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "result = " + SystemClock.now() + "---param = " + object + " from 3";
}
@Override
public String defaultValue() {
return "worker3--default";
}
@Override
public void begin() {
//System.out.println(Thread.currentThread().getName() + "- start --" + System.currentTimeMillis());
}
@Override
public void result(boolean success, String param, WorkResult<String> workResult) {
if (success) {
System.out.println("callback worker3 success--" + SystemClock.now() + "----" + workResult.getResult()
+ "-threadName:" +Thread.currentThread().getName());
} else {
System.err.println("callback worker3 failure--" + SystemClock.now() + "----" + workResult.getResult()
+ "-threadName:" +Thread.currentThread().getName());
}
}
}

871
schisandra-cloud-storage-asyncTool/src/test/java/parallel/TestPar.java Normal file
View File

@@ -0,0 +1,871 @@
package parallel;
import com.jd.platform.async.executor.Async;
import com.jd.platform.async.executor.timer.SystemClock;
import com.jd.platform.async.wrapper.WorkerWrapper;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
/**
* 并行测试
*
* @author wuweifeng wrote on 2019-11-20.
*/
@SuppressWarnings("ALL")
public class TestPar {
public static void main(String[] args) throws Exception {
// testNormal();
// testMulti();
// testMultiReverse();
testMultiError();
// testMultiError2();
// testMulti3();
// testMulti3Reverse();
// testMulti4();
// testMulti4Reverse();
// testMulti5();
// testMulti5Reverse();
// testMulti6();
// testMulti7();
// testMulti8();
// testMulti9();
// testMulti9Reverse();
}
/**
* 3个并行，测试不同时间的超时
*/
private static void testNormal() throws InterruptedException, ExecutionException {
ParWorker w = new ParWorker();
ParWorker1 w1 = new ParWorker1();
ParWorker2 w2 = new ParWorker2();
WorkerWrapper<String, String> workerWrapper2 = new WorkerWrapper.Builder<String, String>()
.worker(w2)
.callback(w2)
.param("2")
.build();
WorkerWrapper<String, String> workerWrapper1 = new WorkerWrapper.Builder<String, String>()
.worker(w1)
.callback(w1)
.param("1")
.build();
WorkerWrapper<String, String> workerWrapper = new WorkerWrapper.Builder<String, String>()
.worker(w)
.callback(w)
.param("0")
.build();
long now = SystemClock.now();
System.out.println("begin-" + now);
Async.beginWork(1500, workerWrapper, workerWrapper1, workerWrapper2);
// Async.beginWork(800, workerWrapper, workerWrapper1, workerWrapper2);
// Async.beginWork(1000, workerWrapper, workerWrapper1, workerWrapper2);
System.out.println("end-" + SystemClock.now());
System.err.println("cost-" + (SystemClock.now() - now));
System.out.println(Async.getThreadCount());
System.out.println(workerWrapper.getWorkResult());
Async.shutDown();
}
/**
* 0,2同时开启,1在0后面
* 0---1
* 2
*/
private static void testMulti() throws ExecutionException, InterruptedException {
ParWorker w = new ParWorker();
ParWorker1 w1 = new ParWorker1();
ParWorker2 w2 = new ParWorker2();
WorkerWrapper<String, String> workerWrapper2 = new WorkerWrapper.Builder<String, String>()
.worker(w2)
.callback(w2)
.param("2")
.build();
WorkerWrapper<String, String> workerWrapper1 = new WorkerWrapper.Builder<String, String>()
.worker(w1)
.callback(w1)
.param("1")
.build();
WorkerWrapper<String, String> workerWrapper = new WorkerWrapper.Builder<String, String>()
.worker(w)
.callback(w)
.param("0")
.next(workerWrapper1)
.build();
long now = SystemClock.now();
System.out.println("begin-" + now);
Async.beginWork(2500, workerWrapper, workerWrapper2);
System.out.println("end-" + SystemClock.now());
System.err.println("cost-" + (SystemClock.now() - now));
Async.shutDown();
}
/**
* 0,2同时开启,1在0后面
* 0---1
* 2
*/
private static void testMultiReverse() throws ExecutionException, InterruptedException {
ParWorker w = new ParWorker();
ParWorker1 w1 = new ParWorker1();
ParWorker2 w2 = new ParWorker2();
WorkerWrapper<String, String> workerWrapper = new WorkerWrapper.Builder<String, String>()
.worker(w)
.callback(w)
.param("0")
.build();
WorkerWrapper<String, String> workerWrapper1 = new WorkerWrapper.Builder<String, String>()
.worker(w1)
.callback(w1)
.param("1")
.depend(workerWrapper)
.build();
WorkerWrapper<String, String> workerWrapper2 = new WorkerWrapper.Builder<String, String>()
.worker(w2)
.callback(w2)
.param("2")
.build();
long now = SystemClock.now();
System.out.println("begin-" + now);
Async.beginWork(2500, workerWrapper, workerWrapper2);
System.out.println("end-" + SystemClock.now());
System.err.println("cost-" + (SystemClock.now() - now));
Async.shutDown();
}
/**
* 0,2同时开启,1在0后面. 组超时,则0和2成功,1失败
* 0---1
* 2
*/
private static void testMultiError() throws ExecutionException, InterruptedException {
ParWorker w = new ParWorker();
ParWorker1 w1 = new ParWorker1();
ParWorker2 w2 = new ParWorker2();
WorkerWrapper<String, String> workerWrapper2 = new WorkerWrapper.Builder<String, String>()
.worker(w2)
.callback(w2)
.param("2")
.build();
WorkerWrapper<String, String> workerWrapper1 = new WorkerWrapper.Builder<String, String>()
.worker(w1)
.callback(w1)
.param("1")
.build();
WorkerWrapper<String, String> workerWrapper = new WorkerWrapper.Builder<String, String>()
.worker(w)
.callback(w)
.param("0")
.next(workerWrapper1)
.build();
long now = SystemClock.now();
System.out.println("begin-" + now);
Async.beginWork(1500, workerWrapper, workerWrapper2);
System.out.println("end-" + SystemClock.now());
System.err.println("cost-" + (SystemClock.now() - now));
Async.shutDown();
}
/**
* 0执行完,同时1和2, 1\2都完成后3
* 1
* 0 3
* 2
*/
private static void testMulti3() throws ExecutionException, InterruptedException {
ParWorker w = new ParWorker();
ParWorker1 w1 = new ParWorker1();
ParWorker2 w2 = new ParWorker2();
ParWorker3 w3 = new ParWorker3();
WorkerWrapper<String, String> workerWrapper3 = new WorkerWrapper.Builder<String, String>()
.worker(w3)
.callback(w3)
.param("3")
.build();
WorkerWrapper<String, String> workerWrapper2 = new WorkerWrapper.Builder<String, String>()
.worker(w2)
.callback(w2)
.param("2")
.next(workerWrapper3)
.build();
WorkerWrapper<String, String> workerWrapper1 = new WorkerWrapper.Builder<String, String>()
.worker(w1)
.callback(w1)
.param("1")
.next(workerWrapper3)
.build();
WorkerWrapper<String, String> workerWrapper = new WorkerWrapper.Builder<String, String>()
.worker(w)
.callback(w)
.param("0")
.next(workerWrapper1, workerWrapper2)
.build();
long now = SystemClock.now();
System.out.println("begin-" + now);
Async.beginWork(3100, workerWrapper);
// Async.beginWork(2100, workerWrapper);
System.out.println("end-" + SystemClock.now());
System.err.println("cost-" + (SystemClock.now() - now));
System.out.println(Async.getThreadCount());
Async.shutDown();
}
/**
* 0执行完,同时1和2, 1\2都完成后3
* 1
* 0 3
* 2
*/
private static void testMulti3Reverse() throws ExecutionException, InterruptedException {
ParWorker w = new ParWorker();
ParWorker1 w1 = new ParWorker1();
ParWorker2 w2 = new ParWorker2();
ParWorker3 w3 = new ParWorker3();
WorkerWrapper<String, String> workerWrapper = new WorkerWrapper.Builder<String, String>()
.worker(w)
.callback(w)
.param("0")
.build();
WorkerWrapper<String, String> workerWrapper2 = new WorkerWrapper.Builder<String, String>()
.worker(w2)
.callback(w2)
.param("2")
.depend(workerWrapper)
.build();
WorkerWrapper<String, String> workerWrapper1 = new WorkerWrapper.Builder<String, String>()
.worker(w1)
.callback(w1)
.param("1")
.depend(workerWrapper)
.build();
WorkerWrapper<String, String> workerWrapper3 = new WorkerWrapper.Builder<String, String>()
.worker(w3)
.callback(w3)
.param("3")
.depend(workerWrapper1, workerWrapper2)
.build();
long now = SystemClock.now();
System.out.println("begin-" + now);
Async.beginWork(3100, workerWrapper);
// Async.beginWork(2100, workerWrapper);
System.out.println("end-" + SystemClock.now());
System.err.println("cost-" + (SystemClock.now() - now));
System.out.println(Async.getThreadCount());
Async.shutDown();
}
/**
* 0执行完,同时1和2, 1\2都完成后3，2耗时2秒，1耗时1秒。3会等待2完成
* 1
* 0 3
* 2
*
* 执行结果0，1，2，3
*/
private static void testMulti4() throws ExecutionException, InterruptedException {
ParWorker w = new ParWorker();
ParWorker1 w1 = new ParWorker1();
ParWorker2 w2 = new ParWorker2();
w2.setSleepTime(2000);
ParWorker3 w3 = new ParWorker3();
WorkerWrapper<String, String> workerWrapper3 = new WorkerWrapper.Builder<String, String>()
.worker(w3)
.callback(w3)
.param("3")
.build();
WorkerWrapper<String, String> workerWrapper2 = new WorkerWrapper.Builder<String, String>()
.worker(w2)
.callback(w2)
.param("2")
.next(workerWrapper3)
.build();
WorkerWrapper<String, String> workerWrapper1 = new WorkerWrapper.Builder<String, String>()
.worker(w1)
.callback(w1)
.param("1")
.next(workerWrapper3)
.build();
WorkerWrapper<String, String> workerWrapper = new WorkerWrapper.Builder<String, String>()
.worker(w)
.callback(w)
.param("0")
.next(workerWrapper1, workerWrapper2)
.build();
long now = SystemClock.now();
System.out.println("begin-" + now);
//正常完毕
Async.beginWork(4100, workerWrapper);
//3会超时
// Async.beginWork(3100, workerWrapper);
//2,3会超时
// Async.beginWork(2900, workerWrapper);
System.out.println("end-" + SystemClock.now());
System.err.println("cost-" + (SystemClock.now() - now));
System.out.println(Async.getThreadCount());
Async.shutDown();
}
/**
* 0执行完,同时1和2, 1\2都完成后3，2耗时2秒，1耗时1秒。3会等待2完成
* 1
* 0 3
* 2
*
* 执行结果0，1，2，3
*/
private static void testMulti4Reverse() throws ExecutionException, InterruptedException {
ParWorker w = new ParWorker();
ParWorker1 w1 = new ParWorker1();
ParWorker2 w2 = new ParWorker2();
w2.setSleepTime(2000);
ParWorker3 w3 = new ParWorker3();
WorkerWrapper<String, String> workerWrapper = new WorkerWrapper.Builder<String, String>()
.worker(w)
.callback(w)
.param("0")
.build();
WorkerWrapper<String, String> workerWrapper3 = new WorkerWrapper.Builder<String, String>()
.worker(w3)
.callback(w3)
.param("3")
.build();
WorkerWrapper<String, String> workerWrapper2 = new WorkerWrapper.Builder<String, String>()
.worker(w2)
.callback(w2)
.param("2")
.depend(workerWrapper)
.next(workerWrapper3)
.build();
WorkerWrapper<String, String> workerWrapper1 = new WorkerWrapper.Builder<String, String>()
.worker(w1)
.callback(w1)
.param("1")
.depend(workerWrapper)
.next(workerWrapper3)
.build();
long now = SystemClock.now();
System.out.println("begin-" + now);
//正常完毕
Async.beginWork(4100, workerWrapper);
//3会超时
// Async.beginWork(3100, workerWrapper);
//2,3会超时
// Async.beginWork(2900, workerWrapper);
System.out.println("end-" + SystemClock.now());
System.err.println("cost-" + (SystemClock.now() - now));
System.out.println(Async.getThreadCount());
Async.shutDown();
}
/**
* 0执行完,同时1和2, 1\2 任何一个执行完后，都执行3
* 1
* 0 3
* 2
*
* 则结果是：
* 0，2，3，1
* 2，3分别是500、400.3执行完毕后，1才执行完
*/
private static void testMulti5() throws ExecutionException, InterruptedException {
ParWorker w = new ParWorker();
ParWorker1 w1 = new ParWorker1();
ParWorker2 w2 = new ParWorker2();
w2.setSleepTime(500);
ParWorker3 w3 = new ParWorker3();
w3.setSleepTime(400);
WorkerWrapper<String, String> workerWrapper3 = new WorkerWrapper.Builder<String, String>()
.worker(w3)
.callback(w3)
.param("3")
.build();
WorkerWrapper<String, String> workerWrapper2 = new WorkerWrapper.Builder<String, String>()
.worker(w2)
.callback(w2)
.param("2")
.next(workerWrapper3, false)
.build();
WorkerWrapper<String, String> workerWrapper1 = new WorkerWrapper.Builder<String, String>()
.worker(w1)
.callback(w1)
.param("1")
.next(workerWrapper3, false)
.build();
WorkerWrapper<String, String> workerWrapper = new WorkerWrapper.Builder<String, String>()
.worker(w)
.callback(w)
.param("0")
.next(workerWrapper1, workerWrapper2)
.build();
long now = SystemClock.now();
System.out.println("begin-" + now);
//正常完毕
Async.beginWork(4100, workerWrapper);
System.out.println("end-" + SystemClock.now());
System.err.println("cost-" + (SystemClock.now() - now));
System.out.println(Async.getThreadCount());
Async.shutDown();
}
/**
* 0执行完,同时1和2, 1\2 任何一个执行完后，都执行3
* 1
* 0 3
* 2
*
* 则结果是：
* 0，2，3，1
* 2，3分别是500、400.3执行完毕后，1才执行完
*/
private static void testMulti5Reverse() throws ExecutionException, InterruptedException {
ParWorker w = new ParWorker();
ParWorker1 w1 = new ParWorker1();
ParWorker2 w2 = new ParWorker2();
w2.setSleepTime(500);
ParWorker3 w3 = new ParWorker3();
w3.setSleepTime(400);
WorkerWrapper<String, String> workerWrapper = new WorkerWrapper.Builder<String, String>()
.worker(w)
.callback(w)
.param("0")
.build();
WorkerWrapper<String, String> workerWrapper3 = new WorkerWrapper.Builder<String, String>()
.worker(w3)
.callback(w3)
.param("3")
.build();
WorkerWrapper<String, String> workerWrapper2 = new WorkerWrapper.Builder<String, String>()
.worker(w2)
.callback(w2)
.param("2")
.depend(workerWrapper, true)
.next(workerWrapper3, false)
.build();
WorkerWrapper<String, String> workerWrapper1 = new WorkerWrapper.Builder<String, String>()
.worker(w1)
.callback(w1)
.param("1")
.depend(workerWrapper, true)
.next(workerWrapper3, false)
.build();
long now = SystemClock.now();
System.out.println("begin-" + now);
//正常完毕
Async.beginWork(4100, workerWrapper);
System.out.println("end-" + SystemClock.now());
System.err.println("cost-" + (SystemClock.now() - now));
System.out.println(Async.getThreadCount());
Async.shutDown();
}
/**
* 0执行完,同时1和2, 必须1执行完毕后，才能执行3. 无论2是否领先1完毕，都要等1
* 1
* 0 3
* 2
*
* 则结果是：
* 0，2，1，3
*
* 2，3分别是500、400.2执行完了，1没完，那就等着1完毕，才能3
*/
private static void testMulti6() throws ExecutionException, InterruptedException {
ParWorker w = new ParWorker();
ParWorker1 w1 = new ParWorker1();
ParWorker2 w2 = new ParWorker2();
w2.setSleepTime(500);
ParWorker3 w3 = new ParWorker3();
w3.setSleepTime(400);
WorkerWrapper<String, String> workerWrapper3 = new WorkerWrapper.Builder<String, String>()
.worker(w3)
.callback(w3)
.param("3")
.build();
//设置2不是必须
WorkerWrapper<String, String> workerWrapper2 = new WorkerWrapper.Builder<String, String>()
.worker(w2)
.callback(w2)
.param("2")
.next(workerWrapper3, false)
.build();
// 设置1是必须的
WorkerWrapper<String, String> workerWrapper1 = new WorkerWrapper.Builder<String, String>()
.worker(w1)
.callback(w1)
.param("1")
.next(workerWrapper3, true)
.build();
WorkerWrapper<String, String> workerWrapper0 = new WorkerWrapper.Builder<String, String>()
.worker(w)
.callback(w)
.param("0")
.next(workerWrapper2, workerWrapper1)
.build();
long now = SystemClock.now();
System.out.println("begin-" + now);
//正常完毕
Async.beginWork(4100, workerWrapper0);
System.out.println("end-" + SystemClock.now());
System.err.println("cost-" + (SystemClock.now() - now));
System.out.println(Async.getThreadCount());
Async.shutDown();
}
/**
* 两个0并行，上面0执行完,同时1和2, 下面0执行完开始1，上面的 必须1、2执行完毕后，才能执行3. 最后必须2、3都完成，才能4
* 1
* 0 3
* 2 4
* ---------
* 0 1 2
*
* 则结果是：
* callback worker0 success--1577242870969----result = 1577242870968---param = 00 from 0-threadName:Thread-1
* callback worker0 success--1577242870969----result = 1577242870968---param = 0 from 0-threadName:Thread-0
* callback worker1 success--1577242871972----result = 1577242871972---param = 11 from 1-threadName:Thread-1
* callback worker1 success--1577242871972----result = 1577242871972---param = 1 from 1-threadName:Thread-2
* callback worker2 success--1577242871973----result = 1577242871973---param = 2 from 2-threadName:Thread-3
* callback worker2 success--1577242872975----result = 1577242872975---param = 22 from 2-threadName:Thread-1
* callback worker3 success--1577242872977----result = 1577242872977---param = 3 from 3-threadName:Thread-2
* callback worker4 success--1577242873980----result = 1577242873980---param = 4 from 3-threadName:Thread-2
*/
private static void testMulti7() throws ExecutionException, InterruptedException {
ParWorker w = new ParWorker();
ParWorker1 w1 = new ParWorker1();
ParWorker2 w2 = new ParWorker2();
ParWorker3 w3 = new ParWorker3();
ParWorker4 w4 = new ParWorker4();
WorkerWrapper<String, String> workerWrapper4 = new WorkerWrapper.Builder<String, String>()
.worker(w4)
.callback(w4)
.param("4")
.build();
WorkerWrapper<String, String> workerWrapper3 = new WorkerWrapper.Builder<String, String>()
.worker(w3)
.callback(w3)
.param("3")
.next(workerWrapper4)
.build();
//下面的2
WorkerWrapper<String, String> workerWrapper22 = new WorkerWrapper.Builder<String, String>()
.worker(w2)
.callback(w2)
.param("22")
.next(workerWrapper4)
.build();
//下面的1
WorkerWrapper<String, String> workerWrapper11 = new WorkerWrapper.Builder<String, String>()
.worker(w1)
.callback(w1)
.param("11")
.next(workerWrapper22)
.build();
//下面的0
WorkerWrapper<String, String> workerWrapper00 = new WorkerWrapper.Builder<String, String>()
.worker(w)
.callback(w)
.param("00")
.next(workerWrapper11)
.build();
//上面的1
WorkerWrapper<String, String> workerWrapper1 = new WorkerWrapper.Builder<String, String>()
.worker(w1)
.callback(w1)
.param("1")
.next(workerWrapper3)
.build();
//上面的2
WorkerWrapper<String, String> workerWrapper2 = new WorkerWrapper.Builder<String, String>()
.worker(w2)
.callback(w2)
.param("2")
.next(workerWrapper3)
.build();
//上面的0
WorkerWrapper<String, String> workerWrapper0 = new WorkerWrapper.Builder<String, String>()
.worker(w)
.callback(w)
.param("0")
.next(workerWrapper1, workerWrapper2)
.build();
long now = SystemClock.now();
System.out.println("begin-" + now);
//正常完毕
Async.beginWork(4100, workerWrapper00, workerWrapper0);
System.out.println("end-" + SystemClock.now());
System.err.println("cost-" + (SystemClock.now() - now));
System.out.println(Async.getThreadCount());
Async.shutDown();
}
/**
* a1 -> b -> c
* a2 -> b -> c
*
* b、c
*/
private static void testMulti8() throws ExecutionException, InterruptedException {
ParWorker w = new ParWorker();
ParWorker1 w1 = new ParWorker1();
w1.setSleepTime(1005);
ParWorker2 w2 = new ParWorker2();
w2.setSleepTime(3000);
ParWorker3 w3 = new ParWorker3();
w3.setSleepTime(1000);
WorkerWrapper<String, String> workerWrapper3 = new WorkerWrapper.Builder<String, String>()
.worker(w3)
.callback(w3)
.param("c")
.build();
WorkerWrapper<String, String> workerWrapper2 = new WorkerWrapper.Builder<String, String>()
.worker(w2)
.callback(w2)
.param("b")
.next(workerWrapper3)
.build();
WorkerWrapper<String, String> workerWrappera1 = new WorkerWrapper.Builder<String, String>()
.worker(w1)
.callback(w1)
.param("a1")
.next(workerWrapper2)
.build();
WorkerWrapper<String, String> workerWrappera2 = new WorkerWrapper.Builder<String, String>()
.worker(w1)
.callback(w1)
.param("a2")
.next(workerWrapper2)
.build();
Async.beginWork(6000, workerWrappera1, workerWrappera2);
Async.shutDown();
}
/**
* w1 -> w2 -> w3
* --- last
* w
* w1和w并行，w执行完后就执行last，此时b、c还没开始，b、c就不需要执行了
*/
private static void testMulti9() throws ExecutionException, InterruptedException {
ParWorker1 w1 = new ParWorker1();
//注意这里，如果w1的执行时间比w长，那么w2和w3肯定不走。 如果w1和w执行时间一样长，多运行几次，会发现w2有时走有时不走
// w1.setSleepTime(1100);
ParWorker w = new ParWorker();
ParWorker2 w2 = new ParWorker2();
ParWorker3 w3 = new ParWorker3();
ParWorker4 w4 = new ParWorker4();
WorkerWrapper<String, String> last = new WorkerWrapper.Builder<String, String>()
.worker(w1)
.callback(w1)
.param("last")
.build();
WorkerWrapper<String, String> wrapperW = new WorkerWrapper.Builder<String, String>()
.worker(w)
.callback(w)
.param("w")
.next(last, false)
.build();
WorkerWrapper<String, String> wrapperW3 = new WorkerWrapper.Builder<String, String>()
.worker(w3)
.callback(w3)
.param("w3")
.next(last, false)
.build();
WorkerWrapper<String, String> wrapperW2 = new WorkerWrapper.Builder<String, String>()
.worker(w2)
.callback(w2)
.param("w2")
.next(wrapperW3)
.build();
WorkerWrapper<String, String> wrapperW1 = new WorkerWrapper.Builder<String, String>()
.worker(w1)
.callback(w1)
.param("w1")
.next(wrapperW2)
.build();
Async.beginWork(6000, wrapperW, wrapperW1);
Async.shutDown();
}
/**
* w1 -> w2 -> w3
* --- last
* w
* w1和w并行，w执行完后就执行last，此时b、c还没开始，b、c就不需要执行了
*/
private static void testMulti9Reverse() throws ExecutionException, InterruptedException {
ParWorker1 w1 = new ParWorker1();
//注意这里，如果w1的执行时间比w长，那么w2和w3肯定不走。 如果w1和w执行时间一样长，多运行几次，会发现w2有时走有时不走
// w1.setSleepTime(1100);
ParWorker w = new ParWorker();
ParWorker2 w2 = new ParWorker2();
ParWorker3 w3 = new ParWorker3();
ParWorker4 w4 = new ParWorker4();
WorkerWrapper<String, String> wrapperW1 = new WorkerWrapper.Builder<String, String>()
.worker(w1)
.callback(w1)
.param("w1")
.build();
WorkerWrapper<String, String> wrapperW = new WorkerWrapper.Builder<String, String>()
.worker(w)
.callback(w)
.param("w")
.build();
WorkerWrapper<String, String> last = new WorkerWrapper.Builder<String, String>()
.worker(w1)
.callback(w1)
.param("last")
.depend(wrapperW)
.build();
WorkerWrapper<String, String> wrapperW2 = new WorkerWrapper.Builder<String, String>()
.worker(w2)
.callback(w2)
.param("w2")
.depend(wrapperW1)
.build();
WorkerWrapper<String, String> wrapperW3 = new WorkerWrapper.Builder<String, String>()
.worker(w3)
.callback(w3)
.param("w3")
.depend(wrapperW2)
.next(last, false)
.build();
Async.beginWork(6000,Executors.newCachedThreadPool(), wrapperW, wrapperW1);
Async.shutDown();
}
}

48
schisandra-cloud-storage-asyncTool/src/test/java/seq/SeqTimeoutWorker.java Normal file
View File

@@ -0,0 +1,48 @@
package seq;
import com.jd.platform.async.callback.ICallback;
import com.jd.platform.async.callback.IWorker;
import com.jd.platform.async.executor.timer.SystemClock;
import com.jd.platform.async.worker.WorkResult;
import com.jd.platform.async.wrapper.WorkerWrapper;
import java.util.Map;
/**
* @author wuweifeng wrote on 2019-11-20.
*/
public class SeqTimeoutWorker implements IWorker<String, String>, ICallback<String, String> {
@Override
public String action(String object, Map<String, WorkerWrapper> allWrappers) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "result = " + SystemClock.now() + "---param = " + object + " from 0";
}
@Override
public String defaultValue() {
return "worker0--default";
}
@Override
public void begin() {
//System.out.println(Thread.currentThread().getName() + "- start --" + System.currentTimeMillis());
}
@Override
public void result(boolean success, String param, WorkResult<String> workResult) {
if (success) {
System.out.println("callback worker0 success--" + SystemClock.now() + "----" + workResult.getResult()
+ "-threadName:" +Thread.currentThread().getName());
} else {
System.err.println("callback worker0 failure--" + SystemClock.now() + "----" + workResult.getResult()
+ "-threadName:" +Thread.currentThread().getName());
}
}
}

49
schisandra-cloud-storage-asyncTool/src/test/java/seq/SeqWorker.java Normal file
View File

@@ -0,0 +1,49 @@
package seq;
import com.jd.platform.async.callback.ICallback;
import com.jd.platform.async.callback.IWorker;
import com.jd.platform.async.executor.timer.SystemClock;
import com.jd.platform.async.worker.WorkResult;
import com.jd.platform.async.wrapper.WorkerWrapper;
import java.util.Map;
/**
* @author wuweifeng wrote on 2019-11-20.
*/
public class SeqWorker implements IWorker<String, String>, ICallback<String, String> {
@Override
public String action(String object, Map<String, WorkerWrapper> allWrappers) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "result = " + SystemClock.now() + "---param = " + object + " from 0";
}
@Override
public String defaultValue() {
return "worker0--default";
}
@Override
public void begin() {
//System.out.println(Thread.currentThread().getName() + "- start --" + System.currentTimeMillis());
}
@Override
public void result(boolean success, String param, WorkResult<String> workResult) {
if (success) {
System.out.println("callback worker0 success--" + SystemClock.now() + "----" + workResult.getResult()
+ "-threadName:" +Thread.currentThread().getName());
} else {
System.err.println("callback worker0 failure--" + SystemClock.now() + "----" + workResult.getResult()
+ "-threadName:" +Thread.currentThread().getName());
}
}
}

48
schisandra-cloud-storage-asyncTool/src/test/java/seq/SeqWorker1.java Normal file
View File

@@ -0,0 +1,48 @@
package seq;
import com.jd.platform.async.callback.ICallback;
import com.jd.platform.async.callback.IWorker;
import com.jd.platform.async.executor.timer.SystemClock;
import com.jd.platform.async.worker.WorkResult;
import com.jd.platform.async.wrapper.WorkerWrapper;
import java.util.Map;
/**
* @author wuweifeng wrote on 2019-11-20.
*/
public class SeqWorker1 implements IWorker<String, String>, ICallback<String, String> {
@Override
public String action(String object, Map<String, WorkerWrapper> allWrappers) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "result = " + SystemClock.now() + "---param = " + object + " from 0";
}
@Override
public String defaultValue() {
return "worker1--default";
}
@Override
public void begin() {
//System.out.println(Thread.currentThread().getName() + "- start --" + System.currentTimeMillis());
}
@Override
public void result(boolean success, String param, WorkResult<String> workResult) {
if (success) {
System.out.println("callback worker1 success--" + SystemClock.now() + "----" + workResult.getResult()
+ "-threadName:" +Thread.currentThread().getName());
} else {
System.err.println("callback worker1 failure--" + SystemClock.now() + "----" + workResult.getResult()
+ "-threadName:" +Thread.currentThread().getName());
}
}
}

48
schisandra-cloud-storage-asyncTool/src/test/java/seq/SeqWorker2.java Normal file
View File

@@ -0,0 +1,48 @@
package seq;
import com.jd.platform.async.callback.ICallback;
import com.jd.platform.async.callback.IWorker;
import com.jd.platform.async.executor.timer.SystemClock;
import com.jd.platform.async.worker.WorkResult;
import com.jd.platform.async.wrapper.WorkerWrapper;
import java.util.Map;
/**
* @author wuweifeng wrote on 2019-11-20.
*/
public class SeqWorker2 implements IWorker<String, String>, ICallback<String, String> {
@Override
public String action(String object, Map<String, WorkerWrapper> allWrappers) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "result = " + SystemClock.now() + "---param = " + object + " from 0";
}
@Override
public String defaultValue() {
return "worker2--default";
}
@Override
public void begin() {
//System.out.println(Thread.currentThread().getName() + "- start --" + System.currentTimeMillis());
}
@Override
public void result(boolean success, String param, WorkResult<String> workResult) {
if (success) {
System.out.println("callback worker2 success--" + SystemClock.now() + "----" + workResult.getResult()
+ "-threadName:" +Thread.currentThread().getName());
} else {
System.err.println("callback worker2 failure--" + SystemClock.now() + "----" + workResult.getResult()
+ "-threadName:" +Thread.currentThread().getName());
}
}
}

71
schisandra-cloud-storage-asyncTool/src/test/java/seq/TestSequential.java Normal file
View File

@@ -0,0 +1,71 @@
package seq;
import com.jd.platform.async.executor.Async;
import com.jd.platform.async.executor.timer.SystemClock;
import com.jd.platform.async.wrapper.WorkerWrapper;
import java.util.concurrent.ExecutionException;
/**
* 串行测试
* @author wuweifeng wrote on 2019-11-20.
*/
public class TestSequential {
public static void main(String[] args) throws InterruptedException, ExecutionException {
SeqWorker w = new SeqWorker();
SeqWorker1 w1 = new SeqWorker1();
SeqWorker2 w2 = new SeqWorker2();
//顺序0-1-2
WorkerWrapper<String, String> workerWrapper2 = new WorkerWrapper.Builder<String, String>()
.worker(w2)
.callback(w2)
.param("2")
.build();
WorkerWrapper<String, String> workerWrapper1 = new WorkerWrapper.Builder<String, String>()
.worker(w1)
.callback(w1)
.param("1")
.next(workerWrapper2)
.build();
WorkerWrapper<String, String> workerWrapper = new WorkerWrapper.Builder<String, String>()
.worker(w)
.callback(w)
.param("0")
.next(workerWrapper1)
.build();
// testNormal(workerWrapper);
testGroupTimeout(workerWrapper);
}
private static void testNormal(WorkerWrapper<String, String> workerWrapper) throws ExecutionException, InterruptedException {
long now = SystemClock.now();
System.out.println("begin-" + now);
Async.beginWork(3500, workerWrapper);
System.out.println("end-" + SystemClock.now());
System.err.println("cost-" + (SystemClock.now() - now));
Async.shutDown();
}
private static void testGroupTimeout(WorkerWrapper<String, String> workerWrapper) throws ExecutionException, InterruptedException {
long now = SystemClock.now();
System.out.println("begin-" + now);
Async.beginWork(2500, workerWrapper);
System.out.println("end-" + SystemClock.now());
System.err.println("cost-" + (SystemClock.now() - now));
Async.shutDown();
}
}

67
schisandra-cloud-storage-asyncTool/src/test/java/seq/TestSequentialTimeout.java Normal file
View File

@@ -0,0 +1,67 @@
package seq;
import com.jd.platform.async.executor.Async;
import com.jd.platform.async.executor.timer.SystemClock;
import com.jd.platform.async.wrapper.WorkerWrapper;
import java.util.concurrent.ExecutionException;
/**
* 串行测试
* @author wuweifeng wrote on 2019-11-20.
*/
@SuppressWarnings("Duplicates")
public class TestSequentialTimeout {
public static void main(String[] args) throws InterruptedException, ExecutionException {
testFirstTimeout();
}
/**
* begin-1576719450476
* callback worker0 failure--1576719451338----worker0--default-threadName:main
* callback worker1 failure--1576719451338----worker1--default-threadName:main
* callback worker2 failure--1576719451338----worker2--default-threadName:main
* end-1576719451338
* cost-862
*/
private static void testFirstTimeout() throws ExecutionException, InterruptedException {
SeqWorker1 w1 = new SeqWorker1();
SeqWorker2 w2 = new SeqWorker2();
SeqTimeoutWorker t = new SeqTimeoutWorker();
WorkerWrapper<String, String> workerWrapper2 = new WorkerWrapper.Builder<String, String>()
.worker(w2)
.callback(w2)
.param("2")
.build();
WorkerWrapper<String, String> workerWrapper1 = new WorkerWrapper.Builder<String, String>()
.worker(w1)
.callback(w1)
.param("1")
.next(workerWrapper2)
.build();
//2在1后面串行
//T会超时
WorkerWrapper<String, String> workerWrapperT = new WorkerWrapper.Builder<String, String>()
.worker(t)
.callback(t)
.param("t")
.next(workerWrapper1)
.build();
long now = SystemClock.now();
System.out.println("begin-" + now);
Async.beginWork(5000, workerWrapperT);
System.out.println("end-" + SystemClock.now());
System.err.println("cost-" + (SystemClock.now() - now));
Async.shutDown();
}
}