皮皮网

【三明治2号指标源码】【源码资本投资前景】【源码函数流程分析】getlocaladdress 源码

来源:负数求补规则对源码 时间:2024-12-24 10:44:52

1.【unimrcpclient源码分析】mrcp components
2.Java如何通过网络进行寻找附近的设备,附源码?
3.跪求一个Java编写的多人聊天程序源代码
4.Dubbo调用超时那些事儿

getlocaladdress 源码

【unimrcpclient源码分析】mrcp components

       配置样例包含六个部分。

       函数unimrcp_client_components_load主要负责这六个组件的加载,下面详细解析各个组件的加载过程。

       加载resource组件时,其结构体mrcp_resource_t定义在mrcp_resource.h,三明治2号指标源码字符串使用apt_str_table_item_t(定义在mrcp_resource_loader.c),mrcp_resource_loader_t和mrcp_resource_factory_t分别位于mrcp_resource_loader.c和mrcp_resource_factory.c。构造mrcp_resource_loader内部是mrcp_resource_factory_t *factory,factory通过mrcp_resource_factory_create构建,参数为MRCP_RESOURCE_TYPE_COUNT的第5个值,整型值为4。

       加载sip-uac组件时,mrcp_sofia_client_config_t结构体(mrcp_sofiasip_client_agent.c)应用于sofia sip协议栈。默认端口和名称设定如下:config->local_port = DEFAULT_SIP_PORT; 默认端口为,config->user_agent_name = DEFAULT_SOFIASIP_UA_NAME; 默认agent name为UniMRCP SofiaSIP,config->origin = DEFAULT_SDP_ORIGIN; 默认sdp origin为UniMRCPClient。IP地址配置通过unimrcp_client_ip_address_get(unimrcp_client.c)实现,可配置为“auto”或“iface”。然后使用mrcp_sofiasip_client_agent_create(mrcp_sofiasip_client_agent.c)创建sofiasip_client。

       加载rtsp-uac组件时,源码资本投资前景指代MRCPv1版本的uac组件。rtsp_client_config_t结构体(mrcp_unirtsp_client_agent.h)用于配置。组件加载通过unimrcp_client_rtsp_uac_load函数完成。

       加载media-engine组件时,配置项仅包含realtime_rate。unimrcp_client_media_engine_load函数负责加载此组件。mpf_engine_t结构体(mpf_engine.c)用于创建mpf_engine,使用mpf_engine_create函数。

       加载rtp-factory组件时,mpf_rtp_config_t结构体(mpf_rtp_descriptor.h)包含可配置项。源码函数流程分析unimrcp_client_rtp_factory_load函数用于加载此组件,并通过mpf_rtp_termination_factory_create(mpf_rtp_termination_factory.c)创建相应的工厂。

Java如何通过网络进行寻找附近的设备,附源码?

       在 Java 中,可以通过使用 Java 的网络编程技术来实现查找附近的设备。具体的做法如下:

       获取本机的 IP 地址和子网掩码,以计算出本机所在网络中的 IP 地址范围。

       使用 for 循环和 InetAddress 类扫描网络中的每一个 IP 地址。

       对于每一个 IP 地址,使用 isReachable() 方法判断其是存储过程报表源码否可达,如果可达则表明该 IP 地址对应的设备存在。

       以下是一份简单的示例代码:

       import java.net.InetAddress;

       import java.net.UnknownHostException;

       public class FindDevices {

       public static void main(String[] args) throws UnknownHostException {

       InetAddress localHost = InetAddress.getLocalHost();

       String hostAddress = localHost.getHostAddress();

       String subnet = hostAddress.substring(0, hostAddress.lastIndexOf(".") + 1);

       for (int i = 1; i < ; i++) {

       String host = subnet + i;

       try {

       InetAddress address = InetAddress.getByName(host);

       if (address.isReachable()) {

       System.out.println(host + " is reachable");

       }

       } catch (Exception e) {

       System.out.println(host + " is not reachable");

       }

       }

       }

       }

       请注意,这是一份示例代码,其中的扫描范围和扫描方法可能不是最佳的,根据实际需要进行修改。

跪求一个Java编写的多人聊天程序源代码

       import java.io.InputStream;

       import java.io.DataInputStream;

       import java.io.InputStreamReader;

       import java.io.OutputStream;

       import java.io.DataOutputStream;

       import java.io.BufferedReader;

       import java.net.ServerSocket;

       import java.net.Socket;

       import java.io.IOException;

       import java.util.Date;

       class Server

       {

       public Server()

       {

       try

       {

       ServerSocket s=new ServerSocket();

       Socket ss=s.accept();

       OutputStream out=ss.getOutputStream();

       DataOutputStream dout=new DataOutputStream(out);

       InputStream in=ss.getInputStream();

       DataInputStream din=new DataInputStream(in);

       System.out.print(din.readUTF()+"!");

       dout.writeUTF("你已经连接到服务器"+"\t"+"你的地址:"+ss.getInetAddress()+"\t"

       +"你的链接端口:"+ss.getLocalPort()+"\n");

       new ReadMessage(din).start();

       new SendMessage(dout).start();

       }

       catch (IOException e)

       {

       e.printStackTrace();

       }

       }

       public static void main(String[] args)

       {

       new Server();

       }

       }

       //接受客户端信息

       class ReadMessage extends Thread

       {

       private DataInputStream din;

       public ReadMessage(DataInputStream din)

       {

       this.din=din;

       }

       public void run()

       {

       String str;

       try

       {

       while (true)

       {

       str=din.readUTF();

       System.out.println(new Date().toLocaleString()+"客户端说:"+str);

       if (str.equals("bye"))

       {

       System.out.println("客户端下线!");

       break;

       }

       }

       }

       catch (IOException e)

       {

       e.printStackTrace();

       }

       }

       }

       // 发出服务器信息

       class SendMessage extends Thread

       {

       private DataOutputStream dout;

       public SendMessage(DataOutputStream dout)

       {

       this.dout=dout;

       }

       public void run()

       {

       InputStreamReader inr=new InputStreamReader(System.in);

       BufferedReader buf=new BufferedReader(inr);

       String str;

       try

       {

       while(true)

       {

       str=buf.readLine();

       dout.writeUTF(str);

       if (str.equals("bye"))

       {

       System.out.println("服务器退出!");

       System.exit(1);

       }

       }

       }

       catch (IOException e)

       {

       e.printStackTrace();

       }

       }

       }

       import java.io.InputStream;

       import java.io.DataInputStream;

       import java.io.InputStreamReader;

       import java.io.OutputStream;

       import java.io.DataOutputStream;

       import java.io.BufferedReader;

       import java.net.Socket;

       import java.io.IOException;

       import java.util.Date;

       class Client

       {

       public Client()

       {

       try

       {

       Socket s=new Socket("..1.2",);

       InputStream in=s.getInputStream();

       DataInputStream din=new DataInputStream(in);

       OutputStream out=s.getOutputStream();

       DataOutputStream dout=new DataOutputStream(out);

       dout.writeUTF("服务器你好!我是客户端");

       System.out.println(din.readUTF());

       new Thread(new SenderMessage(dout)).start();

       new Thread(new ReaderMessage(din)).start();

       }

       catch (IOException e)

       {

       e.printStackTrace();

       }

       }

       public static void main(String[] args)

       {

       new Client();

       }

       }

       class ReaderMessage implements Runnable

       {

       private DataInputStream din;

       public ReaderMessage(DataInputStream din)

       {

       this.din=din;

       }

       public void run()

       {

       String str;

       try

       {

       while(true)

       {

       str=din.readUTF();

       System.out.println(new Date().toLocaleString()+"服务器说:"+str);

       if (str.equals("bye"))

       {

       System.out.println("服务器已经关闭,此程序自动退出!agl源码目录结构");

       break;

       }

       }

       }

       catch (IOException e)

       {

       e.printStackTrace();

       }

       }

       }

       class SenderMessage implements Runnable

       {

       private DataOutputStream dout;

       public SenderMessage(DataOutputStream dout)

       {

       this.dout=dout;

       }

       public void run()

       {

       String str;

       InputStreamReader inf=new InputStreamReader(System.in);

       BufferedReader buf=new BufferedReader(inf);

       try

       {

       while (true)

       {

       str=buf.readLine();

       dout.writeUTF(str);

       if (str.equals("bye"))

       {

       System.out.println("客户端自己退出!");

       System.exit(1);

       }

       }

       }

       catch (IOException e)

       {

       e.printStackTrace();

       }

       }

       }

Dubbo调用超时那些事儿

       其实之前很早就看过Dubbo源码中关于超时这部分的处理逻辑,但是没有记录下来,最近在某脉上看到有人问了这个问题,想着再回顾一下。

开始

       从dubbo的请求开始,看看dubbo(2.6.6)在超时这块是怎么处理的:

com.alibaba.dubbo.remoting.exchange.support.header.HeaderExchangeChannel#request(java.lang.Object, int)@Overridepublic ResponseFuture request(Object request, int timeout) throws RemotingException { if (closed) { throw new RemotingException(this.getLocalAddress(), null, "Failed to send request " + request + ", cause: The channel " + this + " is closed!");}// create request.Request req = new Request();req.setVersion(Version.getProtocolVersion());req.setTwoWay(true);req.setData(request);DefaultFuture future = new DefaultFuture(channel, req, timeout);try { channel.send(req);} catch (RemotingException e) { future.cancel();throw e;}return future;}DefaultFuture

       从返回值ResponseFuture类型可以看出,这是一个异步方法(不等同于Dubbo的异步调用)。那么调用超时的关键可以从ResponseFuture来看:

public interface ResponseFuture { Object get() throws RemotingException;Object get(int timeoutInMillis) throws RemotingException;void setCallback(ResponseCallback callback);boolean isDone();}

       可以看到这是一个接口,从request方法可以得知实现类是DefaultFuture,从构造函数入手:

public DefaultFuture(Channel channel, Request request, int timeout) { this.channel = channel;this.request = request;this.id = request.getId();this.timeout = timeout > 0 ? timeout : channel.getUrl().getPositiveParameter(Constants.TIMEOUT_KEY, Constants.DEFAULT_TIMEOUT);// put into waiting map.FUTURES.put(id, this);CHANNELS.put(id, channel);}

       可以得知每一个DefaultFuture都有一个id,并且等于requestId,timeout是从url中获取的配置,没有时默认ms。

       从代码的注释可以看到FUTURES这个map应该就是关键,是一个waiting map。

       DefaultFuture中还有一个方法:

public static void received(Channel channel, Response response) { try { DefaultFuture future = FUTURES.remove(response.getId());if (future != null) { future.doReceived(response);} else { logger.warn("The timeout response finally returned at "+ (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(new Date()))+ ", response " + response+ (channel == null ? "" : ", channel: " + channel.getLocalAddress()+ " -> " + channel.getRemoteAddress()));}} finally { CHANNELS.remove(response.getId());}}

       可以看到调用的地方为:

       com.alibaba.dubbo.remoting.exchange.support.header.HeaderExchangeHandler#received

@Overridepublic void received(Channel channel, Object message) throws RemotingException { //省略一些代码} else if (message instanceof Response) { handleResponse(channel, (Response) message);//省略一些代码}}

       com.alibaba.dubbo.remoting.exchange.support.header.HeaderExchangeHandler#handleResponse

static void handleResponse(Channel channel, Response response) throws RemotingException { if (response != null && !response.isHeartbeat()) { DefaultFuture.received(channel, response);}}

       回到DefaultFuture.received,可以看到通过Response id从FUTURES中拿了一个DefaultFuture出来,然后调用了doReceived方法,也就是说Response id和Request id 相同。结下来看看doReceived做了什么:

private void doReceived(Response res) { lock.lock();try { response = res;if (done != null) { done.signal();}} finally { lock.unlock();}if (callback != null) { invokeCallback(callback);}}

       首先是加锁,然后通过唤醒了阻塞在Condition上的线程。看看什么地方会阻塞在done这个条件上:

@Overridepublic Object get(int timeout) throws RemotingException { if (timeout <= 0) { timeout = Constants.DEFAULT_TIMEOUT;}if (!isDone()) { long start = System.currentTimeMillis();lock.lock();try { while (!isDone()) { done.await(timeout, TimeUnit.MILLISECONDS);if (isDone() || System.currentTimeMillis() - start > timeout) { break;}}} catch (InterruptedException e) { throw new RuntimeException(e);} finally { lock.unlock();}if (!isDone()) { throw new TimeoutException(sent > 0, channel, getTimeoutMessage(false));}}return returnFromResponse();}

       是get方法,get方法确实在request请求后被调用:

(Result) currentClient.request(inv, timeout).get()

       可以看到get方法的大致逻辑为,先获取锁,然后循环判断isDone,并阻塞等到条件,当条件超时,如果任务完成,或者超过timeout结束循环,接着判断isDone,如果超时抛出TimeoutException。并且通过sent(request请求时间)是否>0()来判断是clientSide还是serverSide超时。

       isDone逻辑如下:

@Overridepublic boolean isDone() { return response != null;}

       如果是正常Response,也有可能是超时的现象,可以看到get方法最后调用了一个函数:

public interface ResponseFuture { Object get() throws RemotingException;Object get(int timeoutInMillis) throws RemotingException;void setCallback(ResponseCallback callback);boolean isDone();}0TIMEOUT SIDE

       SERVER_TIMEOUT(服务端超时): 这个就是正常的我们消费端请求一个RPC接口,服务端由于性能等一些原因处理时间超过了timeout配置时间。

       CLIENT_TIMEOUT:我们可以看到是通过sent(上面有说sent>0)这个来判断是否clientTimeout,那么这个sent什么时候改变呢?就在发送请求的地方:

public interface ResponseFuture { Object get() throws RemotingException;Object get(int timeoutInMillis) throws RemotingException;void setCallback(ResponseCallback callback);boolean isDone();}1

       也就是说handler.sent一旦调用成功返回,那么就不算clientSide Timeout了。那么CLIENT_TIMEOUT大概率就是由于client端网络,系统等原因超时。

原文:/post/