精华内容
下载资源
问答
  • 之前开发springCloud微服务,遇到微服务之间调用事务回滚问题,网上浏览存在多种解决方案。但是最后发现,实现服务回滚的多服务必须要在同一注册中心下,也就是说,必须要有一主服务管理者所有的分布式服务。 ...

           之前开发springCloud微服务,遇到微服务之间调用事务回滚问题,网上浏览存在多种解决方案。但是最后发现,实现服务回滚的多个服务必须要在同一个注册中心下,也就是说,必须要有一个主服务管理者所有的分布式服务。

           如果!两个服务之间不存在任何关联,如何实现事务回滚?

           苦思冥想,终于想到了一个不是办法的办法。

           在服务A调用服务B时,先获取当前时间,将当前时间作为调用服务B的请求参数。

           服务B获取服务A的参数时,先执行一系列逻辑业务操作,到接口执行到最后,服务B也获取当前时间。然后和服务A请求参数

    的时间做差运算。得到时间差

            我们进行服务调用无非是使用rest或者rpc  ,可以设置调用接口限时。

            在服务B判断得到的时间差是否大于等于接口限时,如果大于等于则服务B抛出异常,由于服务B抛出了异常,则调用者服务A‘

    也自然抛出异常,这样就避免了因为网络延迟,或者业务复杂执行时间长而造成的事务为题。

            当然这样做,被调用服务需要写判断代码。

              

             

           

    展开全文
  •  Restful接口调用,前端一般使用ajax调用,后端可以使用的方法比较多,  本次介绍三种:  1.HttpURLConnection实现  2.HttpClient实现  3.Spring的RestTemplate 2.HttpURLConnection实现 1 @...

    1.基本介绍

      Restful接口的调用,前端一般使用ajax调用,后端可以使用的方法比较多,

      本次介绍三种:

        1.HttpURLConnection实现

        2.HttpClient实现

        3.Spring的RestTemplate

     

    2.HttpURLConnection实现

     1 @Controller
     2 public class RestfulAction {
     3     
     4     @Autowired
     5     private UserService userService;
     6 
     7     // 修改
     8     @RequestMapping(value = "put/{param}", method = RequestMethod.PUT)
     9     public @ResponseBody String put(@PathVariable String param) {
    10         return "put:" + param;
    11     }
    12 
    13     // 新增
    14     @RequestMapping(value = "post/{param}", method = RequestMethod.POST)
    15     public @ResponseBody String post(@PathVariable String param,String id,String name) {
    16         System.out.println("id:"+id);
    17         System.out.println("name:"+name);
    18         return "post:" + param;
    19     }
    20     
    21 
    22     // 删除
    23     @RequestMapping(value = "delete/{param}", method = RequestMethod.DELETE)
    24     public @ResponseBody String delete(@PathVariable String param) {
    25         return "delete:" + param;
    26     }
    27 
    28     // 查找
    29     @RequestMapping(value = "get/{param}", method = RequestMethod.GET)
    30     public @ResponseBody String get(@PathVariable String param) {
    31         return "get:" + param;
    32     }
    33     
    34     
    35     // HttpURLConnection 方式调用Restful接口
    36     // 调用接口
    37     @RequestMapping(value = "dealCon/{param}")
    38     public @ResponseBody String dealCon(@PathVariable String param) {
    39         try {
    40             String url = "http://localhost:8080/tao-manager-web/";
    41             url+=(param+"/xxx");
    42             URL restServiceURL = new URL(url);
    43             HttpURLConnection httpConnection = (HttpURLConnection) restServiceURL
    44                     .openConnection();
    45             //param 输入小写,转换成 GET POST DELETE PUT 
    46             httpConnection.setRequestMethod(param.toUpperCase());
    47 //            httpConnection.setRequestProperty("Accept", "application/json");
    48             if("post".equals(param)){
    49                 //打开输出开关
    50                 httpConnection.setDoOutput(true);
    51 //                httpConnection.setDoInput(true);
    52                 
    53                 //传递参数
    54                 String input = "&id="+ URLEncoder.encode("abc", "UTF-8");
    55                 input+="&name="+ URLEncoder.encode("啊啊啊", "UTF-8");
    56                 OutputStream outputStream = httpConnection.getOutputStream();
    57                 outputStream.write(input.getBytes());
    58                 outputStream.flush();
    59             }
    60             if (httpConnection.getResponseCode() != 200) {
    61                 throw new RuntimeException(
    62                         "HTTP GET Request Failed with Error code : "
    63                                 + httpConnection.getResponseCode());
    64             }
    65             BufferedReader responseBuffer = new BufferedReader(
    66                     new InputStreamReader((httpConnection.getInputStream())));
    67             String output;
    68             System.out.println("Output from Server:  \n");
    69             while ((output = responseBuffer.readLine()) != null) {
    70                 System.out.println(output);
    71             }
    72             httpConnection.disconnect();
    73         } catch (MalformedURLException e) {
    74             e.printStackTrace();
    75         } catch (IOException e) {
    76             e.printStackTrace();
    77         }
    78         return "success";
    79     }
    80 
    81 }

     

     

     

    3.HttpClient实现

      1 package com.taozhiye.controller;
      2 
      3 import org.apache.http.HttpEntity;
      4 import org.apache.http.HttpResponse;
      5 import org.apache.http.NameValuePair;
      6 import org.apache.http.client.HttpClient;
      7 import org.apache.http.client.entity.UrlEncodedFormEntity;
      8 import org.apache.http.client.methods.HttpDelete;
      9 import org.apache.http.client.methods.HttpGet;
     10 import org.apache.http.client.methods.HttpPost;
     11 import org.apache.http.client.methods.HttpPut;
     12 import org.apache.http.impl.client.HttpClients;
     13 import org.apache.http.message.BasicNameValuePair;
     14 import org.springframework.beans.factory.annotation.Autowired;
     15 import org.springframework.stereotype.Controller;
     16 import org.springframework.web.bind.annotation.PathVariable;
     17 import org.springframework.web.bind.annotation.RequestMapping;
     18 import org.springframework.web.bind.annotation.RequestMethod;
     19 import org.springframework.web.bind.annotation.ResponseBody;
     20 
     21 import com.fasterxml.jackson.databind.ObjectMapper;
     22 import com.taozhiye.entity.User;
     23 import com.taozhiye.service.UserService;
     24 
     25 import java.io.BufferedReader;
     26 import java.io.IOException;
     27 import java.io.InputStreamReader;
     28 import java.io.OutputStream;
     29 import java.net.HttpURLConnection;
     30 import java.net.MalformedURLException;
     31 import java.net.URL;
     32 import java.net.URLEncoder;
     33 import java.util.ArrayList;
     34 import java.util.List;
     35 
     36 @Controller
     37 public class RestfulAction {
     38     
     39     @Autowired
     40     private UserService userService;
     41 
     42     // 修改
     43     @RequestMapping(value = "put/{param}", method = RequestMethod.PUT)
     44     public @ResponseBody String put(@PathVariable String param) {
     45         return "put:" + param;
     46     }
     47 
     48     // 新增
     49     @RequestMapping(value = "post/{param}", method = RequestMethod.POST)
     50     public @ResponseBody User post(@PathVariable String param,String id,String name) {
     51         User u = new User();
     52         System.out.println(id);
     53         System.out.println(name);
     54         u.setName(id);
     55         u.setPassword(name);
     56         u.setEmail(id);
     57         u.setUsername(name);
     58         return u;
     59     }
     60     
     61 
     62     // 删除
     63     @RequestMapping(value = "delete/{param}", method = RequestMethod.DELETE)
     64     public @ResponseBody String delete(@PathVariable String param) {
     65         return "delete:" + param;
     66     }
     67 
     68     // 查找
     69     @RequestMapping(value = "get/{param}", method = RequestMethod.GET)
     70     public @ResponseBody User get(@PathVariable String param) {
     71         User u = new User();
     72         u.setName(param);
     73         u.setPassword(param);
     74         u.setEmail(param);
     75         u.setUsername("爱爱啊");
     76         return u;
     77     }
     78 
     79     
     80     
     81     @RequestMapping(value = "dealCon2/{param}")
     82     public @ResponseBody User dealCon2(@PathVariable String param) {
     83         User user = null;
     84         try {
     85             HttpClient client = HttpClients.createDefault();
     86             if("get".equals(param)){
     87                 HttpGet request = new HttpGet("http://localhost:8080/tao-manager-web/get/"
     88                         +"啊啊啊");
     89                 request.setHeader("Accept", "application/json");
     90                 HttpResponse response = client.execute(request);
     91                 HttpEntity entity = response.getEntity();
     92                 ObjectMapper mapper = new ObjectMapper();
     93                 user = mapper.readValue(entity.getContent(), User.class);
     94             }else if("post".equals(param)){
     95                 HttpPost request2 = new HttpPost("http://localhost:8080/tao-manager-web/post/xxx");
     96                 List<NameValuePair> nvps = new ArrayList<NameValuePair>();  
     97                 nvps.add(new BasicNameValuePair("id", "啊啊啊"));  
     98                 nvps.add(new BasicNameValuePair("name", "secret"));
     99                 UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(nvps, "GBK");
    100                 request2.setEntity(formEntity);
    101                 HttpResponse response2 = client.execute(request2);
    102                 HttpEntity entity = response2.getEntity();
    103                 ObjectMapper mapper = new ObjectMapper();
    104                 user = mapper.readValue(entity.getContent(), User.class);
    105             }else if("delete".equals(param)){
    106                 
    107             }else if("put".equals(param)){
    108                 
    109             }
    110         } catch (Exception e) {
    111             e.printStackTrace();
    112         }
    113         return user;
    114     }
    115     
    116     
    117 }

     

    4.Spring的RestTemplate

    springmvc.xml增加

     1     <!-- 配置RestTemplate -->
     2     <!--Http client Factory -->
     3     <bean id="httpClientFactory"
     4         class="org.springframework.http.client.SimpleClientHttpRequestFactory">
     5         <property name="connectTimeout" value="10000" />
     6         <property name="readTimeout" value="10000" />
     7     </bean>
     8 
     9     <!--RestTemplate -->
    10     <bean id="restTemplate" class="org.springframework.web.client.RestTemplate">
    11         <constructor-arg ref="httpClientFactory" />
    12     </bean>

    controller

     1 @Controller
     2 public class RestTemplateAction {
     3 
     4     @Autowired
     5     private RestTemplate template;
     6 
     7     @RequestMapping("RestTem")
     8     public @ResponseBody User RestTem(String method) {
     9         User user = null;
    10         //查找
    11         if ("get".equals(method)) {
    12             user = template.getForObject(
    13                     "http://localhost:8080/tao-manager-web/get/{id}",
    14                     User.class, "呜呜呜呜");
    15             
    16             //getForEntity与getForObject的区别是可以获取返回值和状态、头等信息
    17             ResponseEntity<User> re = template.
    18                     getForEntity("http://localhost:8080/tao-manager-web/get/{id}",
    19                     User.class, "呜呜呜呜");
    20             System.out.println(re.getStatusCode());
    21             System.out.println(re.getBody().getUsername());
    22             
    23         //新增
    24         } else if ("post".equals(method)) {
    25             HttpHeaders headers = new HttpHeaders();
    26             headers.add("X-Auth-Token", UUID.randomUUID().toString());
    27             MultiValueMap<String, String> postParameters = new LinkedMultiValueMap<String, String>();
    28             postParameters.add("id", "啊啊啊");
    29             postParameters.add("name", "部版本");
    30             HttpEntity<MultiValueMap<String, String>> requestEntity = new HttpEntity<MultiValueMap<String, String>>(
    31                     postParameters, headers);
    32             user = template.postForObject(
    33                     "http://localhost:8080/tao-manager-web/post/aaa", requestEntity,
    34                     User.class);
    35         //删除
    36         } else if ("delete".equals(method)) {
    37             template.delete("http://localhost:8080/tao-manager-web/delete/{id}","aaa");
    38         //修改
    39         } else if ("put".equals(method)) {
    40             template.put("http://localhost:8080/tao-manager-web/put/{id}",null,"bbb");
    41         }
    42         return user;
    43 
    44     }
    45 }

     

    展开全文
  • 如果有两个系统一个his系统,一个医保系统。 要实现数据互通,怎么做?最好有代码和实现步骤。 his系统怎么把数据上传到医保系统, 医保系统怎么把计算信息返回到his系统? 想知道其中的具体过程,最好有简单的代码...
  • 假定系统管理微服务的实例名称为system, 在系统管理中查询码表 :/...在自己的微服务中调用系统管理的查询码表接口写法如下: DataDictionaryService @AuthorizedFeignClient(name ="system",fallback = Data...

    假定系统管理微服务的实例名称为system,

    在系统管理中查询码表 :/api/system/codeTable/queryDataDictionaryByDicCode

     

     

    在自己的微服务中调用系统管理的查询码表接口写法如下:


    DataDictionaryService

    @AuthorizedFeignClient(name = "system",fallback = DataDictionaryServiceImpl.class)
    public interface DataDictionaryService extends BaseService<BaseEntity, BaseDTO> {

        /**
         * 根据dic_key获取value
         * @param dto
         * @return
         */
        @RequestMapping(method= RequestMethod.POST,value="/api/system/codeTable/queryDataDictionaryByDicCode",consumes = "application/json")
        ResponseDTO queryDataDictionaryByDicCode(@RequestBody DataDictionaryDTO dto);

    }

    ----------------------------------------------------------------------------------------------------------------------------

    DataDictionaryServiceImpl

    @Service
    public class DataDictionaryServiceImpl implements DataDictionaryService {

        @Override
        public ResponseDTO queryDataDictionaryByDicCode(DataDictionaryDTO dto) {
            return new ResponseDTO("300","system==queryDataDictionaryByDicCode==调用失败");
        }
    }

    展开全文
  • 系统调用

    千次阅读 多人点赞 2019-03-02 17:47:48
    程序接口通常是由各种类型的系统调用所组成的,因而,也可以说,系统调用提供了用户程序和操作系统之间接口,应用程序通过系统调用实现其与 OS 的通信,并可取得它的服务。 处理器(CPU)=运算器+控制器+...

    程序接口是 OS 专门为用户程序设置的,也是用户程序取得 OS 服务的唯一途径。程序接口通常是由各种类型的系统调用所组成的,因而,也可以说,系统调用提供了用户程序和操作系统之间的接口,应用程序通过系统调用实现其与 OS 的通信,并可取得它的服务

     

    处理器(CPU)=运算器+控制器+寄存器+高速缓存

     

    系统调用的基本概念


    通常,在 OS 的核心中都设置了一组用于实现各种系统功能的子程序(过程),并将它们提供给应用程序调用。

     


    系统态和用户态


    在计算机系统中,通常运行着两类程序:系统程序和应用程序,为了保证系统程序不被应用程序有意或无意地破坏,为计算机设置了两种状态:

    • 系统态(也称为管态或核心态),操作系统在系统态运行
    • 用户态(也称为目态),应用程序只能在用户态运行。

    在实际运行过程中,处理机会在系统态和用户态间切换。相应地,现代多数操作系统将 CPU 的指令集分为特权指令和非特权指令两类。


    1) 特权指令——在系统态时运行的指令

    • 对内存空间的访问范围基本不受限制,不仅能访问用户存储空间,也能访问系统存储空间,
    • 特权指令只允许操作系统使用,不允许应用程序使用,否则会引起系统混乱。

     

    2) 非特权指令——在用户态时运行的指令

    一般应用程序所使用的都是非特权指令,它只能完成一般性的操作和任务,不能对系统中的硬件和软件直接进行访问,其对内存的访问范围也局限于用户空间。

     

     

    系统调用

     

    如上所述,一方面由于系统提供了保护机制,防止应用程序直接调用操作系统的过程,从而避免了系统的不安全性。但另一方面,应用程序又必须取得操作系统所提供的服务,否则,应用程序几乎无法作任何有价值的事情,甚至无法运行。为此,在操作系统中提供了系统调用,使应用程序可以通过系统调用的方法,间接调用操作系统的相关过程,取得相应的服务

    当应用程序中需要操作系统提供服务时,如请求 I/O 资源或执行 I/O 操作,应用程序必须使用系统调用命令。由操作系统捕获到该命令后,便将 CPU 的状态从用户态转换到系统态,然后执行操作系统中相应的子程序(例程),完成所需的功能。执行完成后,系统又将CPU 状态从系统态转换到用户态,再继续执行应用程序。

     

    系统调用和一般调用的区别:

    (1) 运行在不同的系统状态——调用程序是运行在用户态,而被调用程序是运行在系统态。

    (2) 状态的转换通过软中断进入

    • 一般的过程调用并不涉及到系统状态的转换,可直接由调用过程转向被调用过程。
    • 系统调用不允许由调用过程直接转向被调用过程。

    通常都是通过软中断机制,先由用户态转换为系统态,经核心分析后,才能转向相应的系统调用处理子程序。

    (3) 返回问题。

    在采用了抢占式(剥夺)调度方式的系统中,在被调用过程执行完后,要对系统中所有要求运行的进程做优先权分析。当调用进程仍具有最高优先级时,才返回到调用进程继续执行;否则,将引起重新调度,以便让优先权最高的进程优先执行。此时,将把调用进程放入就绪队列。

    (4) 嵌套调用。

    像一般过程一样,系统调用也可以嵌套进行,即在一个被调用过程的执行期间,还可以利用系统调用命令去调用另一个系统调用。当然,每个系统对嵌套调用的深度都有一定的限制,例如最大深度为 6。


    中断机制


    系统调用是通过中断机制实现的,并且一个操作系统的所有系统调用都通过同一个中断入口来实现。对于拥有保护机制的操作系统来说,中断机制本身也是受保护的,

     

     


    系统调用的类型


    对于一般通用的 OS 而言,可将其所提供的系统调用分为:进程控制、文件操纵、通信管理和系统维护等几大类。

     


    进程控制类系统调用


    这类系统调用主要用于对进程的控制,如创建一个新的进程和终止一个进程的运行,获得和设置进程属性等。


    1) 创建和终止进程的系统调用
    在多道程序环境下,为使多道程序能并发执行,必须先利用创建进程的系统调用来为欲参加并发执行的各程序分别创建一个进程。当进程已经执行结束时、 或因发生异常情况而不能继续执行时,可利用终止进程的系统调用来结束该进程的运行。

     

    2) 获得和设置进程属性的系统调用
    当我们创建了一个(些)新进程后,为了能控制它(们)的运行,应当能了解、 确定和重新设置它(们)的属性。这些属性包括: 进程标识符、进程优先级、最大允许执行时间等。此时,我们可利用获得进程属性的系统调用,来了解某进程的属性,利用设置进程属性的系统调用,来确定和重新设置进程的属性。


    3) 等待某事件出现的系统调用
    进程在运行过程中,有时需要等待某事件(条件)出现后方可继续执行。例如,一进程在创建了一个(些)新进程后,需要等待它(们)运行结束后,才能继续执行,此时可利用等待子进程结束的系统调用进行等待;

     


    文件操纵类系统调用


    对文件进行操纵的系统调用数量较多,有创建文件、删除文件、打开文件、关闭文件、读文件、写文件、建立目录、移动文件的读/写指针、改变文件的属性等。


    1) 创建和删除文件
    当用户需要在系统中存放程序或数据时,可利用创建文件的系统调用 creat,由系统根据用户提供的文件名和存取方式来创建一个新文件;当用户已不再需要某文件时,可利用删除文件的系统调用 unlink 将指名文件删除。


    2) 打开和关闭文件
    用户在第一次访问某个文件之前,应先利用打开文件的系统调用 open,将指名文件打开,即系统将在用户(程序)与该文件之间建立一条快捷通路。在文件被打开后,系统将给用户返回一个该文件的句柄或描述符;当用户不再访问某文件时,又可利用关闭文件的系统调用 close,将此文件关闭,即断开该用户程序与该文件之间的快捷通路。


    3) 读和写文件
    用户可利用读系统调用 read,从已打开的文件中读出给定数目的字符,并送至指定的缓冲区中;同样,用户也可利用写系统调用 write,从指定的缓冲区中将给定数目的字符写入指定文件中。read 和 write 两个系统调用是文件操纵类系统调用中使用最频繁的。

     


    进程通信类系统调用


    在 OS 中经常采用两种进程通信方式,即消息传递方式和共享存储区方式。

    当系统中采用消息传递方式时

    1. 先打开一个连接(由源进程发出一条打开连接的系统调用 open connection,目标进程则应利用接受连接的系统调用 accept connection
    2. 可以利用发送消息的系统调用 send message 或者用接收消息的系统调用 receive message 来交换信息。
    3. 通信结束后,还须再利用关闭连接的系统调用 close connection 结束通信。

    用户在利用共享存储区进行通信

    1. 先利用建立共享存储区的系统调用来建立一个共享存储区
    2. 再利用建立连接的系统调用将该共享存储区连接到进程自身的虚地址空间上
    3. 然后便可利用读和写共享存储区的系统调用实现相互通信。

    除上述的三类外,常用的系统调用还包括设备管理类系统调用和信息维护类系统调用,

     

     


    系统调用的实现

     

    系统调用的实现与一般过程调用的实现相比,两者间有很大差异。对于系统调用,控制是由原来的用户态转换为系统态,这是借助于中断和陷入机制来完成的,在该机制中包括中断和陷入硬件机构中断与陷入处理程序两部分。当应用程序使用 OS 的系统调用时,产生一条相应的指令,CPU 在执行这条指令时发生中断,并将有关信号送给中断和陷入硬件机构,该机构收到信号后,启动相关的中断与陷入处理程序进行处理,实现该系统调用所需要的功能。

     

    中断和陷入硬件机构

    1) 中断和陷入的概念(面试考点——中断与异常的区别)

    中断是指 CPU 对系统发生某事件时的这样一种响应: CPU 暂停正在执行的程序,在保留现场后自动地转去执行该事件的中断处理程序;执行完后,再返回到原程序的断点处继续执行。

    下图 表示中断时 CPU 的活动轨迹。还可进一步把中断分为外中断内中断

    • 外中断——是指由于外部设备事件所引起的中断,如通常的磁盘中断、打印机中断等;
    • 内中断——是指由于 CPU 内部事件所引起的中断,如程序出错(非法指令、地址越界)。内中断(trap)也被译为“捕获”或“陷入”。

    通常,陷入是由于执行了现行指令所引起的;而中断则是由于系统中某事件引起的,该事件与现行指令无关。由于系统调用引起的中断属于内中断,因此把由于系统调用引起中断的指令称为陷入指令。

     

    2) 中断和陷入向量(百度面试考过中断向量)
     

    • 针对不同的设备编制不同的中断处理程序,并把该程序的入口地址放在某特定的内存单元中。
    • 不同的设备也对应着不同的处理机状态字PSW,且把它放在与中断处理程序入口指针相邻接的特定单元中。

    在进行中断处理时,只要有了这样两个字,便可转入相应设备的中断处理程序,重新装配处理机的状态字和优先级,进行对该设备的处理。因此,我们把这两个字称为中断向量。相应地,把存放这两个字的单元称为中断向量单元

    类似地,对于陷入,也有陷入向量,不同的系统调用对应不同的陷入向量,在进行陷入处理时,根据陷入指令中的陷入向量,转入实现相应的系统调用功能的子程序,即陷入处理程序。由所有的中断向量和陷入向量构成了中断和陷入向量表,如图所示。

     

     

     

     


    UNIX 系统调用

     

     UNIX 系统调用的类型


    进程控制


    该类系统调用包括:创建进程的系统调用 fork、终止进程的系统调用 exit、等待子进程结束的系统调用 wait 等十多条。


    (1) 创建进程(fork)。

    一个进程可以利用 fork 系统调用来创建一个新进程。新进程是作为调用者的子进程,它继承了其父进程的环境、 已打开的所有文件、根目录和当前目录等,即它继承了父进程几乎所有的属性,并具有与其父进程基本上相同的进程映像。


    (2) 终止进程(exit)。

    一个进程可以利用 exit 实现自我终止。通常,在父进程创建子进程时,便在子进程的末尾安排一条 exit 系统调用。这样,子进程在完成规定的任务后,便可进行自我终止。子进程终止后,留下一记账信息 status,其中包含了子进程运行时记录下来的各种统计信息。


    (3) 等待子进程结束(wait)。

    wait 用于将调用者进程自身挂起,直至它的某一子进程终止为止。这样,父进程可以利用 wait 使自身的执行与子进程的终止同步。


    (4) 执行一个文件(exec)。

    exec 可使调用者进程的进程映像(包括用户程序和数据等)被一个可执行的文件覆盖,此即改变调用者进程的进程映像。该系统调用是 UNIX 系统中最复杂的系统调用之一。


    (5) 获得进程 ID。

    UNIX 系统提供了一组用于获得进程标识符的系统调用,比如,可利用 getpid 系统调用来获得调用进程的标识符,利用 getpgrp 系统调用来获得调用进程的进程组 ID,以及利用 getppid 系统调用来获得调用进程的父进程 ID 等。


    (6) 获得用户 ID。

    UNIX 系统提供了一组用于获得用户 ID 的系统调用,如 getuid 可用于获得真正的用户 ID,geteuid 用于获得有效用户 ID,getgid 用于获得真正用户组 ID 等。


    (7) 进程暂停(pause)。

    可用此系统调用将调用进程挂起,直至它收到一个信号为止。

     

     

    文件操纵


    用于对文件进行操纵的系统调用是数量最多的一类系统调用,其中包括创建文件、打开文件、关闭文件、读文件及写文件等二十多条。


    (1) 创建文件(creat)。

    系统调用 creat 的功能是根据用户提供的文件名和许可权方式,来创建一个新文件或重写一个已存文件。如果系统中不存在指名文件,核心便以给定的文件名和许可权方式来创建一个新文件;如果系统中已有同名文件,核心便释放其已有的数据块。创建后的文件随即被打开,并返回其文件描述符 fd。若 creat 执行失败,便返回“-1”。


    (2) 打开文件(open)。

    open 的功能是把有关的文件属性从磁盘拷贝到内存中,以及在用户和指名文件之间建立一条快捷的通路,并给用户返回一个文件描述符 fd。文件被打开后,用户对文件的任何操作都只须使用 fd 而非路径名。

     

    (3) 关闭文件(close)。

    在 UNIX 系统中,由于允许一个文件被多个进程所共享,故只有在无其他任何进程需要此文件时,才能真正关闭该文件


    (4) 读和写文件 read 和 write。

    仅当用户利用 open 打开指定文件后,方可调用 read 或write 对文件执行读或写操作。两个系统调用都要求用户提供三个输入参数:

    • ① 文件描述符fd。
    • ② buf 缓冲区首址。对读而言,这是用户所要求的信息传送的目标地址;对写而言,这则是信息传送的源地址。
    • ③ 用户要求传送的字节数 n byte。

    系统调用 read 的功能是试图从 fd 所指示的文件中去读入 n byte 个字节的数据,并将它们送至由指针 buf 所指示的缓冲区中;系统调用 write 的功能是试图把 n byte 个字节数据,从指针 buf 所指示的缓冲区中写到由 fd 所指向的文件中。


    (5) 连接和去连接(link 和 unlink)。

    为了实现文件共享,必须记住所有共享该文件的用户数目。为此,在该文件的索引结点中设置了一个连接计数 link。每当有一用户要共享某文件时,须利用系统调用 link 来建立该用户(进程)与此文件之间的连接,并对 i.link 做加 1操作。当用户不再使用此文件时,应利用系统调用 unlink 去断开此连接,亦即做 i.link 的减1 操作。当 i.link 减 1 后结果为 0 时,表示已无用户需要此文件,此时才能将该文件从文件系统中删除。故在 UNIX 系统中并无一条删除文件的系统调用。

     

     

    进程间的通信


    为了实现进程间的通信,在 UNIX 系统中提供了一个用于进程间通信的软件包,简称IPC。它由消息机制、共享存储器机制和信号量机制三部分组成。在每一种通信机制中,都提供了相应的系统调用供用户程序进行进程间的同步与通信之用。

    (1) 消息机制。

    用户(进程)在利用消息机制进行通信时,必须先利用 msgget 系统调用来建立一个消息队列。若成功,便返回消息队列描述符 msgid,以后用户便可利用 msgid 去访问该消息队列。用户(进程)可利用发送消息的系统调用 msgsend 向用户指定的消息队列发送消息;利用 msgrcv 系统调用从指定的消息队列中接收指定类型的消息。

    (2) 共享存储器机制。

    当用户(进程)要利用共享存储器机制进行通信时,必须先利用shmget 系统调用来建立一个共享存储区,若成功,便返回该共享存储区描述符 shmid。以后,用户便可利用 shmid 去访问该共享存储区。进程在建立了共享存储区之后,还必须再利用shmat 将该共享存储区连接到本进程的虚地址空间上。以后,在进程之间便可利用该共享存储区进行通信。当进程不再需要该共享存储区时,可利用 shmdt 系统调用来拆除进程与共享存储区间的连接。

    (3) 信号量机制。

    在 UNIX 系统中所采用的信号量机制,允许将一组信号量形成一个信号量集,并对这组信号量施以原子操作

     

     

    信息维护

     

    在 UNIX 系统中,设置了许多条用于系统维护的系统调用。


    (1) 设置和获得时间。

    超级用户可利用设置时间的系统调用(stime),来设置系统的日期和时间。如果调用进程并非超级用户,则 stime 失败。一般用户可利用获得时间的系统调用time 来获得当前的日期和时间。

    (2) 获得进程和子进程时间(times)。

    利用该系统调用可获得进程及其子进程所使用的CPU 时间,其中包括调用进程在用户空间执行指令所花费的时间,系统为调用进程所花费的 CPU 时间、子进程在用户空间所用的 CPU 时间、系统为各子进程所花费的 CPU 时间等,并可将这些时间填写到一个指定的缓冲区。

    (3) 设置文件访问和修改时间(utime)。

    该系统调用用于设置指名文件被访问和修改的时间。如果该系统调用的参数 times 为 NULL 时,文件主和对该文件具有写权限的用户,可将对该文件的访问和修改时间设置为当前时间;如果 times 不为 NULL,则把 times 解释为指向 utim buf 结构的指针,此时,文件主和超级用户能将访问时间和修改时间置入 utim buf结构中。

    (4) 获得当前 UNIX 系统的名称(uname)。

    利用该系统调用可将有关 UNIX 系统的信息存储在 utsname 结构中。 这些信息包括 UNIX 系统名称的字符串、系统在网络中的名称、 硬件的标准名称等。

     

     

    展开全文
  • 不同java项目之间接口的相互调用

    万次阅读 热门讨论 2019-05-05 14:17:38
    大致思路就是项目A利用工具类调用项目B的接口进行一功能实现,记录一下 工具类 package com.xxx.tools.utils; import jdk.internal.instrumentation.Logger; import net.sf.json.JSONObject; import org.apach....
  • java模块之间调用接口的回调)

    万次阅读 2018-03-23 11:15:29
    模块间调用在一应用系统中,无论使用何种语言开发,必然存在模块之间调用调用的方式分为几种:(1)同步调用同步调用是最基本并且最简单的一种调用方式,类A的方法a()调用类B的方法b(),一直等待b()方法执行...
  • 不同springCloud项目互相调用接口

    万次阅读 2018-09-05 11:18:44
    有A,B两个springCloud项目,B项目的提供restful接口供A项目调用,B项目不在A的...1.调用接口类 public static String defaultConnection(String method, String path, int timeout, int readTimeout, String data...
  • 系统调用、API之间的关系(图)

    万次阅读 2018-06-06 16:36:45
    1.为什么用户程序不能直接访问系统...当用户进程必须访问内核或使用某个内核函数时,就得使用系统调用(System Call)。在Linux中,系统调用是用户空间访问内核空间的唯一途径。 2.什么是系统调用?答:系统调用就...
  • 如何实现两个系统之间的数据同步

    万次阅读 2017-02-25 15:54:58
    a.Dubbo接口的注册与调用 b.使用jms异步消息传递实现定时任务轮循 c.Activemq消息队列 学习Java的同学注意了!!!学习过程中遇到什么问题或者想获取学习资源的话,欢迎加入Java学习交流群,群号码:543120397...
  • Java调用外部接口

    万次阅读 2018-08-03 15:18:15
    进行java的C/S软件开发时,对接了一些第三方提供的网页接口。 使用接口的方式没有想象的那么难。 比方说提供的接口是一GET形式时,在网页上...下面是一简单的POST接口调用实例: P:param参数可使用JSONObj...
  • 这个东西说大不大,但说小也不小,因为所有对开放API接口调用都需要先流经这个系统。纯属个人观点,欢迎大家指正。  先描述下基本场景: 系统API接口日均调用次数预计1亿次,提供5台服务器。...
  • 导读: ... 大家可以关注我个人公众号,所有分享内容,会在公众号第一时间推送,且阅读排版更好。 愿大家的学习,轻松且愉快。 如果大家觉得有用,希望转发...对于一个企业来说,肯定不是一个系统就能够支持所有业务...
  • 系统调用 就是用户空间应用程序和内核提供的服务之间的一个接口。由于服务是在内核中提供的...在本文中,我将探究 Linux SCI,演示如何向 2.6.20 内核添加一个系统调用,然后从用户空间来使用这个函数。我们还将研究在
  • TCP 系统调用

    千次阅读 2016-03-24 17:06:46
    典型的 TCP 客户机和服务器应用程序通过发布 TCP 系统调用序列来获取某些函数。这些系统调用包括socket ()、bind ()、listen ()、accept ()、send () 和 receive()。本文介绍在应用程序发布 TCP 系统...
  • read 系统调用剖析

    千次阅读 2015-11-20 17:27:37
    Linux 系统调用(SCI,system call interface)的实现机制实际上是一多路汇聚以及分解的过程,该汇聚点就是 0x80 中断这入口点(X86 系统结构)。也就是说,所有系统调用都从用户空间中汇聚到 0x80 中断点,同时...
  • 系统调用的概念及原理

    千次阅读 多人点赞 2019-10-31 16:48:30
    系统调用是用户进程进入内核的接口层,它本身并非内核函数,但它是由内核函数实现的,进入内核后,不同的系统调用会找到相应的内核函数,这些内核函数被称为系统调用的“服务例程”。 比如系统调用getpid()实际调用...
  • 深入浅出系统调用的原理

    千次阅读 2018-06-03 14:58:20
    什么是系统调用 系统调用就是应用程序与系统内核之间接口。通过系统调用访问系统资源。2.为什么需要系统调用 由于系统有限的资源可能被多不同的应用程序同时访问可因此,如果不加以保护...
  • Linux系统调用

    万次阅读 2012-04-21 20:39:29
    目录: 1. Linux系统调用原理 2. 系统调用的实现 3. Linux系统调用分类...系统调用,顾名思义,说的是操作系统提供给用户程序调用的一组“特殊”接口。用户程序可以通过这组“特殊”接口来获得操作系统内核提供的
  • Java WebService接口生成和调用 图文详解

    万次阅读 多人点赞 2017-04-22 10:48:24
    依据Web Service规范实施的应用之间, 无论它们所使用的语言、 平台或内部协议是什么, 都可以相互交换数据。Web Service是自描述、 自包含的可用网络模块, 可以执行具体的业务功能。Web Service也很容易部署, ...
  • C++ 函数调用系统调用的区别

    千次阅读 2018-02-06 10:59:27
     所谓系统调用就是用户在程序中调用操作系统所提供的一子功能,也就是系统API,系统调用可以被看做特殊的公共子程序。系统中的各种共享资源都由操作系统统一掌管,因此在用户程序中,凡是与资源有关的操作(如...
  • Webservice实现调用外部接口

    千次阅读 2019-06-25 18:35:31
    经过学习可以了解到:webservice是可以跨平台,跨开发语言去实现客户端去调用服务端接口,从而达到数据的交换传输。 有篇文章有句话总结得很好:抄录自https://www.cnblogs.com/xdp-gacl/p/4048937.html(侵删): ...
  • 1.feign的远程调用(http接口调用) 2.RestTemplate 下面参考别的博客我自己的项目来介绍这种方式~ 1.feign实现springboot/springcloud间的远程HTTP调用 参考博文:springboot feign使用 1.1 pom文件中添加相关...
  • WebService接口开发和调用

    千次阅读 2018-04-18 20:45:39
    WebService是一种可以接收从Internet上的其它系统中传递过来的请求,轻量级的独立的通讯技术。依据Web Service规范实施的应用之间, 无论它们所使用的语言、 平台或内部协议是什么, 都可以相互交换数据。通过SOAP在...
  • 1、ContentProvider简单介绍ContentProvider以在不同的应用程序之间共享数据,...比如我们有两个app,分别是ContentProviderServer和ContentProviderClient1)、需要在app里面ContentProviderServer创建自己的数据...
  • 调用别人接口如何跳过登陆

    千次阅读 2019-07-10 17:53:21
    有时候在接口对接数据时,常常会碰到这样的问题,就是请求接口的时候,他没有返回你想要的数据,而是返回一“登录界面”的html,你说蛋疼不蛋疼...... 而出现这种情况是需要进行登录验证的,那么,我们该如何做呢...
  • 系统调用原理及详细过程

    千次阅读 多人点赞 2020-07-09 21:24:23
    系统调用原理及详细过程 为什么要有系统调用?...每操作系统都会提供一套接口,以供应用程序使用。这些接口往往通过中断来实现。 系统调用与运行库(标准库) 系统调用的弊端 使用不便。操作系统提供的
  • 微服务的调用接口

    万次阅读 2016-12-04 12:09:07
    微服务的调用接口     微服务的调用:   微服务也是服务,我们一般认为微服务都是不同的实例提供的。这些实例通常和调用者运行在不同的进程中(根据部署模式不同,多微服务实例到是有可能在一进程中...
  • 系统调用和库函数及API的区别

    万次阅读 多人点赞 2016-05-03 13:39:48
    是操作系统为用户态运行的进程和硬件设备(如CPU、磁盘、打印机等)进行交互提供的一组接口,即就是设置在应用程序和硬件设备之间的一个接口层。可以说是操作系统留给用户程序的一个接口。 二、 库函数: 顾名思

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 624,173
精华内容 249,669
关键字:

两个系统之间调用接口