锐客网

  1. 首页 > 睿知 > it技术 > >

java异步代码 java异步代码捕捉不到异常

线程IT技术

求 JAVA 异步观察者模式 的源代码（完整的），不要同步的，好的给加分package TestObserver;
import java.util.Iterator;
import java.util.Vector;
/**
*
* @author Seastar
*/
interface Observed {
public void addObserver(Observer o);
public void removeObserver(Observer o);
public void update();
}
interface Observer {
public void takeAction();
}
class Invoker {
private Observer o;
Handler handler;
public Invoker(Observer o) {
new Handler();
this.o = o;
}
private class Handler extends Thread {
public Handler() {
handler = this;
}
@Override
public void run() {
o.takeAction();
}
}
public boolean TestSameObserver(Observer o) {
return o == this.o;
}
public void invoke() {
handler.start();
}
}
class ObservedObject implements Observed {
private VectorInvoker observerList = new VectorInvoker();
public void addObserver(Observer o) {
observerList.add(new Invoker(o));
}
public void removeObserver(Observer o) {
IteratorInvoker it = observerList.iterator();
while (it.hasNext()) {
Invoker i = it.next();
if (i.TestSameObserver(o)) {
observerList.remove(i);
break;
}
}
}
public void update() {
for (Invoker i : observerList) {
i.invoke();
}
}
}
class ObserverA implements Observer {
public void takeAction() {
System.out.println("I am Observer A ,state changed ,so i have to do something");
}
}
class ObserverB implements Observer {
public void takeAction() {
System.out.println("I am Observer B ,i was told to do something");
}
}
class ObserverC implements Observer {
public void takeAction() {
System.out.println("I am Observer C ,I just look ,and do nothing");
}
}
public class Main {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
ObserverA a = new ObserverA();
ObserverB b = new ObserverB();
ObserverC c = new ObserverC();
ObservedObject oo = new ObservedObject();
oo.addObserver(a);
oo.addObserver(b);
oo.addObserver(c);
for (int i = 0; i5;i) {
oo.addObserver(new Observer() {
public void takeAction() {
System.out.println("我是山寨观察者" "，谁敢拦我");
}
});
}
//sometime oo changed ,so it calls update and informs all observer
oo.update();
}
}
观察者模式的精髓在于注册一个观察者观测可能随时变化的对象，对象变化时就会自动通知观察者，
这样在被观测对象影响范围广 ， 可能引起多个类的行为改变时很好用，因为无需修改被观测对象的代码就可以增加被观测对象影响的类 ， 这样的设计模式使得代码易于管理和维护，并且减少了出错几率
至于异步机制实际是个噱头 ， 可以有观测对象来实现异步 ， 也可以有观察者自身实现，这个程序实际是观测对象实现了异步机制，方法是在观察者类外包装了一层invoker类
java后端怎么接收前端的异步请求?前端提交
POST /api/test HTTP/1.1
Host: 192.168.135.69:81
Connection: keep-alive
Content-Length: 18
Origin:
User-Agent: Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/604.1.38 (KHTML, like Gecko) Version/11.0 Mobile/15A372 Safari/604.1
Content-Type: application/x-www-form-urlencoded
Accept: */*
Referer:
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
数据类型
{"phone":"222222"}
后台代码
@At
@Ok("json")
@Filters
@POST
@AdaptBy(type= JsonAdaptor.class)
public Object test(@Param("..") NutMap nutMap, HttpServletRequest req) {undefined
System.out.println("nutMap::"nutMap);
System.out.println("longin ::"req);
return Result.success("system.success");
}
报错信息
2019-01-05 20:02:20,560 org.nutz.ioc.loader.combo.ComboIocLoader.printFoundIocBean(ComboIocLoader.java:226) DEBUG - Found IocObject(portalGlobalsNavService) in AnnotationIocLoader(packages=[com.yunqi])
2019-01-05 20:02:20,560 org.nutz.ioc.impl.NutIoc.get(NutIoc.java:223) DEBUG -Make...'portalGlobalsNavService'
2019-01-05 20:02:20,560 org.nutz.ioc.impl.ScopeContext.save(ScopeContext.java:65) DEBUG - Save object 'portalGlobalsNavService' to [app]
2019-01-05 20:02:20,560 org.nutz.ioc.impl.NutIoc.get(NutIoc.java:166) DEBUG - Get 'dao'
2019-01-05 20:02:20,560 org.nutz.ioc.aop.impl.DefaultMirrorFactory.getMirror(DefaultMirrorFactory.java:76) DEBUG - Load class com.yunqi.modules.service.portal.PortalGlobalsNavService without AOP
2019-01-05 20:02:20,560 org.nutz.ioc.impl.NutIoc.get(NutIoc.java:166) DEBUG - Get 'dao'
2019-01-05 20:02:20,561 org.nutz.service.EntityService.(EntityService.java:41) DEBUG - Get TypeParams for self : com.yunqi.modules.models.portal.Portal_Globals_navnutMap::null
longin ::org.apache.shiro.web.servlet.ShiroHttpServletRequest@334e3d74
2019-01-05 20:02:20,572 com.yunqi.common.processor.LogTimeProcessor.process(LogTimeProcessor.java:24) DEBUG - [POST]URI=/app/test 60ms
————————————————
版权声明：本文为CSDN博主「weixin_39657249」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明 。
原文链接：
java队列实现异步执行在整个思路上要调整一下
1、会有很多线程给一个队列上添加任务
2、有一个或者多个线程逐个执行队列的任务
考虑一下几点：
1、没有任务时，队列执行线程处于等待状态
2、添加任务时，激活队列执行线程，全部run起来 ， 首先抢到任务的执行，其他全部wait
给个小例子吧
package org;
import java.util.LinkedList;
import java.util.List;
public class Queues {
public static ListTask queue = new LinkedListTask();
/**
* 假如 参数o 为任务
* @param o
*/
public static void add (Task t){
synchronized (Queues.queue) {
Queues.queue.add(t); //添加任务
Queues.queue.notifyAll();//激活该队列对应的执行线程，全部Run起来
}
}
static class Task{
public void test(){
System.out.println("我被执行了");
}
}
}
package org;
import java.util.List;
public class Exec implements Runnable{
@Override
public void run() {
while(true){
synchronized (Queues.queue) {
while(Queues.queue.isEmpty()){ //
try {
Queues.queue.wait(); //队列为空时，使线程处于等待状态
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("wait...");
}
Queues.Task t= Queues.queue.remove(0); //得到第一个
t.test(); //执行该任务
System.out.println("end");
}
}
}
public static void main(String[] args) {
Exec e = new Exec();
for (int i = 0; i2; i) {
new Thread(e).start(); //开始执行时 ， 队列为空，处于等待状态
}
//上面开启两个线程执行队列中的任务，那就是先到先得了
//添加一个任务测试
Queues.Task t =new Queues.Task();
Queues.add(t); //执行该方法，激活所有对应队列 ， 那两个线程就会开始执行啦
}
}
上面的就是很简单的例子了
java的多线程不异步怎么办可使用同步组件CountDownLatch、CyclicBarrier等使异程同步 。Java异步会导致代码出现诸多不可控因素，这时可可使用同步组件CountDownLatch、CyclicBarrier等进行修复 。多线程并发时，多个线程同时请求同一个资源，必然导致此资源的数据不安全，A线程修改了B线程的处理的数据，而B线程又修改了A线程处理的数理 。显然这是由于全局资源造成的，有时为了解决此问题，优先考虑使用局部变量 ， 退而求其次使用同步代码块，出于这样的安全考虑就必须牺牲系统处理性能，加在多线程并发时资源挣夺最激烈的地方，这就实现了线程的同步机制 。
java中什么同步什么是异步分别用在什么地方java同步指java异步代码的是synchronized机制java异步代码 ， 而非synchronized的都是异步，弄懂同步的概念就大致明白java异步代码了两者的差别 。
有关同步java异步代码：
synchronized用来修饰一个方法或者一个代码块，它用来保证在同一时刻最多只有一个线程执行该段代码 。
一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行 。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块 。
二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块 。
三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞 。
四、第三个例子同样适用其它同步代码块 。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁 。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞 。
五、以上规则对其它对象锁同样适用 。
示例代码：
public class Thread1 implements Runnable {
public void run() {
synchronized(this) {
for (int i = 0; i5; i) {
System.out.println(Thread.currentThread().getName()" synchronized loop "i);
}
}
}
public static void main(String[] args) {
Thread1 t1 = new Thread1();
Thread ta = new Thread(t1, "A");
Thread tb = new Thread(t1, "B");
ta.start();
tb.start();
}
}
结果：
A synchronized loop 0
A synchronized loop 1
A synchronized loop 2
A synchronized loop 3
A synchronized loop 4
B synchronized loop 0
B synchronized loop 1
B synchronized loop 2
B synchronized loop 3
B synchronized loop 4
【java异步代码 java异步代码捕捉不到异常】java异步代码的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java异步代码捕捉不到异常、java异步代码的信息别忘了在本站进行查找喔 。

    推荐阅读


    上一篇：sqlserver表的联结，Sqlserver表批量添加数据

    下一篇：如何确定服务器类型？ 怎么查是哪种服务器