linux_libevent框架_libevent 框架

LIBEVENT 框架
从LAMP说起: 是一个缩写，它指一组通常一起使用来运行动态网站或者服务器的自由软件
Linux - 操作系统
Apache - 网页服务器
MySQL - 数据库管理系统（或者数据库服务器）
PHP Perl 或 Python - 脚本语言

C10K 问题：并发能力突破不了1万连接

libevent是一个轻量级的开源的高性能的事件触发的网络库，适用于windows、linux、bsd等多种平台，内部使用select、epoll、kqueue等系统调用管理事件机制。
它被众多的开源项目使用，例如大名鼎鼎的memcached等。
特点：
事件驱动，高性能;
轻量级，专注于网络(相对于ACE);
开放源码，代码相当精炼、易读;
跨平台，支持Windows、Linux、BSD和Mac OS;
支持多种I/O多路复用技术（epoll、poll、dev/poll、select和kqueue等），在不同的操作系统下，做了多路复用模型的抽象，可以选择使用不同的模型，通过事件函数提供服务;
支持I/O，定时器和信号等事件;

采用Reactor模式;
libevent是一个典型的reactor模式的实现。

普通的函数调用机制：程序调用某个函数，函数执行，程序等待，函数将结果返回给调用程序（如果含有函数返回值的话），也就是顺序执行的。
Reactor模式的基本流程：应用程序需要提供相应的接口并且注册到reactor反应器上，如果相应的事件发生的话，那么reactor将自动调用相应的注册的接口函数（类似于回调函数）通知你，所以libevent是事件触发的网络库。

libevent的功能
Libevent提供了事件通知，io缓存事件，定时器，超时，异步解析dns，事件驱动的http server以及一个rpc框架。
事件通知：当文件描述符可读可写时将执行回调函数。
IO缓存：缓存事件提供了输入输出缓存，能自动的读入和写入，用户不必直接操作io。
定时器：libevent提供了定时器的机制，能够在一定的时间间隔之后调用回调函数。
信号：触发信号，执行回调。
异步的dns解析：libevent提供了异步解析dns服务器的dns解析函数集。
事件驱动的http服务器：libevent提供了一个简单的，可集成到应用程序中的HTTP服务器。
RPC客户端服务器框架：libevent为创建RPC服务器和客户端创建了一个RPC框架，能自动的封装和解封数据结构。

libevent官网
http://libevent.org/

安装步骤
注意：以root用户身份操作
1、下载源码包
https://github.com/libevent/libevent/releases/download/release-2.1.12-stable/libevent-2.1.12-stable.tar.gz
2、解压
tar zxvf libevent-2.1.12-stable.tar.gz
3、配置安装路径
cd libevent-2.1.12-stable
./configure --disable-openssl
4、编译并安装
make
make install

5、测试libevent是否安装成功：
# ls -la /usr/local/include | grep event

6、如果编译后的程序提示找不到libvent的so，则创建库的链接和缓存文件
ldconfig
编译选项 -levent

实现简单的客户端和服务器端通信
需求：客户端从控制台逐行输入数据，按回车键后将数据发送给服务器端，
服务器端收到请求后，再将收到的数据回传给客户端显示.
client.c

#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<errno.h>
#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<event.h>
#include<event2/util.h>
#include<iostream>

/*2.实现简单的客户端和服务器端通信
需求：客户端从控制台逐行输入数据，按回车键后将数据发送给服务器端，
	  服务器端收到请求后，再将收到的数据回传给客户端显示.*/

using namespace std;

#define MAX_LINKING_NUNBER 1024

typedef struct sockaddr s_sa;

//连接到服务器
int connect_server(const char* server_ip, const int port);

//把内容读取到控制台
void cmd_read_data(int fd, short events, void* arg);

//通过socket从服务器读取内容
void socket_read_data(int fd, short events, void* arg);

int main(int argc,char**argv) {

	if (argc < 3) {
		cout << "请输入两个参数: please input two parameters!" << endl;;
		return -1;
	}

	//两个参数依次是服务器的ip地址和端口号
	int sockfd = connect_server(argv[1], atoi(argv[2]));//atoi就是把()的参数转换为int类型

	if (sockfd == -1) {
		cout << "tcp 连接出错: tcp connect error!" << endl;
		return -1;
	}

	cout << "连接到服务器成功: to server successfully!" << endl;

	struct event_base* base = event_base_new();

	struct event* ev_sockfd = event_new(base, sockfd, EV_READ | EV_PERSIST, socket_read_data, NULL);

	event_add(ev_sockfd, NULL);

	//监听终端输入事件
	struct event* ev_cmd = event_new(base, STDIN_FILENO, EV_READ | EV_PERSIST, cmd_read_data, (void*)&sockfd);

	event_add(ev_cmd, NULL);

	event_base_dispatch(base);

	cout << "程序结束: finished!" << endl;

	return 0;
}

int connect_server(const char* server_ip, const int port) {

	int sockfd=0;
	int status=0;
	int save_error=0;

	struct sockaddr_in server_addr;

	memset(&server_addr, 0, sizeof(server_addr));

	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(port);
	status = inet_aton(server_ip, &server_addr.sin_addr);

	if (status == 0) {//服务器的地址数据不合法
		errno = EINVAL;
		return-1;
	}

	sockfd = socket(PF_INET, SOCK_STREAM, 0);
	if (sockfd == -1) {
		return sockfd;
	}

	status = connect(sockfd, (s_sa*)&server_addr, sizeof(server_addr));

	if (status == -1) {
		save_error = errno;
		close(sockfd);
		errno = save_error;//可能存在的错误
		return -1;
	}

	return sockfd;
}

void cmd_read_data(int fd, short events, void* arg) {

	char msg[MAX_LINKING_NUNBER];

	int ret = read(fd, msg, sizeof(msg) - 1);
	if (ret <= 0) {
		cout << "读取失败: read fail!"<< endl;
		exit(1);
	}

	int sockfd = *((int*)arg);//*((int*)arg)表示先把arg转换为int类型的指针变量,然后再解引

	if (msg[ret - 1] == '\n')
		msg[ret - 1] = '\0';
	else
		msg[ret] = '\0';

	//把终端的消息发送给服务器,客户端忽略性能考虑,直接利用阻塞方式发送
	cout << "内容写到服务器: data write to server!" << endl;

	write(sockfd, msg, ret);
}

void socket_read_data(int fd, short events, void* arg) {

	char msg[MAX_LINKING_NUNBER];

	//为了简单起见,不考虑读一半数据的情况
	int len = read(fd, msg, sizeof(msg) - 1);
	if (len == 0) {
		cout << "当前连接关闭直接退出: connection close exit!" << endl;
		exit(1);
	}
	else if (len < 0) {
		cerr << "数据读取出错: data read fail!" << endl;
		return;
	}

	msg[len] = '\0';

	cout << "接收到来自服务器的内容: recv from server:" << msg << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

server1.c

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
 
#include <unistd.h>
#include <event.h>
#include <event2/event.h>
#include <assert.h> 
 
#define BUFLEN  1024

typedef struct _ConnectStat {
	struct event*  ev;
	char buf[BUFLEN];
}ConnectStat;

//echo 服务实现相关代码
ConnectStat * stat_init(int fd, struct event *ev);
 
 
void accept_connection(int fd, short events, void* arg);
void do_echo_request(int fd, short events, void *arg);
void do_echo_response(int fd, short events, void *arg);
 
int tcp_server_init(int port, int listen_num);

struct event_base* base;

int main(int argc, char** argv)
{
 
    int listener = tcp_server_init(9999, 10);
    if( listener == -1 )
    {
        perror(" tcp_server_init error ");
        return -1;
    }
 
    base = event_base_new();
 
    //添加监听客户端请求连接事件
    struct event* ev_listen = event_new(base, listener, EV_READ | EV_PERSIST,
                                         accept_connection, base);
    event_add(ev_listen, NULL);
 
 
    event_base_dispatch(base);
 
    return 0;
}

ConnectStat * stat_init(int fd, struct event *ev) {
	ConnectStat * temp = NULL;
	temp = (ConnectStat *)malloc(sizeof(ConnectStat));

	if (!temp) {
		fprintf(stderr, "malloc failed. reason: %m\n");
		return NULL;
	}

	memset(temp, '\0', sizeof(ConnectStat));
	temp->ev = ev;

}
 
void  accept_connection(int fd, short events, void* arg)
{
    evutil_socket_t sockfd;
 
    struct sockaddr_in client;
    socklen_t len = sizeof(client);
 
    sockfd = accept(fd, (struct sockaddr*)&client, &len );
    evutil_make_socket_nonblocking(sockfd);
 
    printf("accept a client %d\n", sockfd);
 
    struct event_base* base = (struct event_base*)arg;
	
 
    //仅仅是为了动态创建一个event结构体
    struct event *ev = event_new(NULL, -1, 0, NULL, NULL);
    ConnectStat *stat = stat_init(sockfd, ev);
    
    //将动态创建的结构体作为event的回调参数
    event_assign(ev, base, sockfd, EV_READ ,
                 do_echo_request, (void*)stat);
 
    event_add(ev, NULL);
}
 
 
void do_echo_request(int fd, short events, void *arg)
{
    
    ConnectStat *stat = (ConnectStat *)arg;
    struct event *ev = stat->ev;
    char *msg = stat->buf;
    printf("do echo request ...\n");
	
    int len = read(fd, msg, BUFLEN - 1);
	
    if( len <= 0 )
    {
        printf("connectin close or some error happen when read\n");
        event_free(ev);
        close(fd);
        free(stat);
        return ;
    }
 
    msg[len] = '\0';
    printf("recv from client<<<< %s\n", msg);
    
    event_set(ev,  fd, EV_WRITE, do_echo_response, (void*)stat);
    ev->ev_base = base;        
    event_add(ev, NULL);
    //write(fd, reply_msg, strlen(reply_msg) );
}

void do_echo_response(int fd, short events, void *arg) {
	ConnectStat * stat = (ConnectStat *)(arg);
	struct event *ev = NULL;
	
	assert(stat!=NULL);
	ev = stat->ev;
	
	int len = strlen(stat->buf);
        printf("write to client>>>> %s\n", stat->buf);
	int _s = write(fd, stat->buf, len);
    if (_s > 0)
    {
            printf("write successfully.\n");
	}else if (_s == 0)  //client:close
    {
        fprintf(stderr,"Remote connection[fd: %d] has been closed\n", fd);
		goto  ERR_EXIT;
    }
    else //err occurred.
    {
        fprintf(stderr,"read faield[fd: %d], reason:%s [%d]\n",fd , strerror(errno), _s);
		goto  ERR_EXIT;
    }
	
    event_set(ev,  fd, EV_READ, do_echo_request, (void*)stat);
    ev->ev_base = base;        
    event_add(ev, NULL);
    return ;
	
ERR_EXIT:
    event_free(ev);
    close(fd);
    free(stat);      
}
 
 
 
typedef struct sockaddr SA;
int tcp_server_init(int port, int listen_num)
{
    int errno_save;
    evutil_socket_t listener;// int listener;
 
    listener = socket(AF_INET, SOCK_STREAM, 0);
    if( listener == -1 )
        return -1;
 
    //允许多次绑定同一个地址。要用在socket和bind之间
	//等同于 int opt = 1;
	//setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
	
    evutil_make_listen_socket_reuseable(listener);
 
    struct sockaddr_in sin;
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = 0;
    sin.sin_port = htons(port);
 
    if( bind(listener, (SA*)&sin, sizeof(sin)) < 0 )
        goto error;
 
    if( listen(listener, listen_num) < 0)
        goto error;
 
 
    //跨平台统一接口，将套接字设置为非阻塞状态
    evutil_make_socket_nonblocking(listener);
 
    return listener;
 
    error:
        errno_save = errno;
        evutil_closesocket(listener);
        errno = errno_save;
 
        return -1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198

服务升级，使用缓冲事件
//创建bufferevent
struct bufferevent* bev = bufferevent_socket_new(base, sockfd,BEV_OPT_CLOSE_ON_FREE);

//当有数据可读或socket关闭时会调用回调函数
bufferevent_setcb(bev, server_msg_cb, NULL, event_cb, (void*)ev_cmd);

//使bufferevent 生效
bufferevent_enable(bev, EV_READ | EV_PERSIST);

//读取数据
size_t len = bufferevent_read(bev, msg, sizeof(msg));

//写数据
bufferevent_write(bev, msg, size);

server2.c

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
 
#include <unistd.h>
#include <event.h>
#include <event2/event.h>
#include <assert.h> 
 
#define BUFLEN  1024

typedef struct _ConnectStat {
	//struct event*  ev;
	struct bufferevent* bev;
	char buf[BUFLEN];
}ConnectStat;

//echo 服务实现相关代码
ConnectStat * stat_init(int fd, struct bufferevent *bev);
 
 
void accept_connection(int fd, short events, void* arg);
void do_echo_request(struct bufferevent* bev, void* arg);
void event_cb(struct bufferevent *bev, short event, void *arg);
//void do_echo_response(int fd, short events, void *arg);
 
int tcp_server_init(int port, int listen_num);

struct event_base* base;

int main(int argc, char** argv)
{
 
    int listener = tcp_server_init(9999, 10);
    if( listener == -1 )
    {
        perror(" tcp_server_init error ");
        return -1;
    }
 
    base = event_base_new();
 
    //添加监听客户端请求连接事件
    struct event* ev_listen = event_new(base, listener, EV_READ | EV_PERSIST,
                                         accept_connection, base);
    event_add(ev_listen, NULL);
 
 
    event_base_dispatch(base);
 
    return 0;
}

ConnectStat * stat_init(int fd, struct bufferevent *bev) {
	ConnectStat * temp = NULL;
	temp = (ConnectStat *)malloc(sizeof(ConnectStat));

	if (!temp) {
		fprintf(stderr, "malloc failed. reason: %m\n");
		return NULL;
	}

	memset(temp, '\0', sizeof(ConnectStat));
	temp->bev = bev;

}
 
void  accept_connection(int fd, short events, void* arg)
{
    evutil_socket_t sockfd;
 
    struct sockaddr_in client;
    socklen_t len = sizeof(client);
 
    sockfd = accept(fd, (struct sockaddr*)&client, &len );
    evutil_make_socket_nonblocking(sockfd);
 
    printf("accept a client %d\n", sockfd);
 
    struct event_base* base = (struct event_base*)arg;
	
 
	struct bufferevent* bev = bufferevent_socket_new(base, sockfd, BEV_OPT_CLOSE_ON_FREE);
	ConnectStat *stat = stat_init(sockfd, bev);
	
    bufferevent_setcb(bev, do_echo_request, NULL, event_cb, stat);
    bufferevent_enable(bev, EV_READ | EV_PERSIST);
	
}
 
 
void do_echo_request(struct bufferevent* bev, void* arg)
{
    
    ConnectStat *stat = (ConnectStat *)arg;
    char *msg = stat->buf;
    printf("do echo request ...\n");
	
	size_t len = bufferevent_read(bev, msg, BUFLEN);
 
    msg[len] = '\0';
    printf("recv from client<<<< %s\n", msg);
 
    bufferevent_write(bev, msg, strlen(msg));
	
   
}


void event_cb(struct bufferevent *bev, short event, void *arg)
{
	ConnectStat *stat = (ConnectStat *)arg;
 
    if (event & BEV_EVENT_EOF)
        printf("connection closed\n");
    else if (event & BEV_EVENT_ERROR)
        printf("some other error\n");
 
    //这将自动close套接字和free读写缓冲区
    bufferevent_free(bev);
	free(stat);
}
 
 
 
typedef struct sockaddr SA;
int tcp_server_init(int port, int listen_num)
{
    int errno_save;
    evutil_socket_t listener;// int listener;
 
    listener = socket(AF_INET, SOCK_STREAM, 0);
    if( listener == -1 )
        return -1;
 
    //允许多次绑定同一个地址。要用在socket和bind之间
	//等同于 int opt = 1;
	//setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
	
    evutil_make_listen_socket_reuseable(listener);
 
    struct sockaddr_in sin;
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = 0;
    sin.sin_port = htons(port);
 
    if( bind(listener, (SA*)&sin, sizeof(sin)) < 0 )
        goto error;
 
    if( listen(listener, listen_num) < 0)
        goto error;
 
 
    //跨平台统一接口，将套接字设置为非阻塞状态
    evutil_make_socket_nonblocking(listener);
 
    return listener;
 
    error:
        errno_save = errno;
        evutil_closesocket(listener);
        errno = errno_save;
 
        return -1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

进一步升级,使用evconnlistener_new_bin
struct evconnlistener listener
= evconnlistener_new_bind(base, listener_cb, base,
LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE,
10, (struct sockaddr)&sin,
sizeof(struct sockaddr_in));

server3.c

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
 
#include <unistd.h>
#include <event.h>
#include <event2/event.h>
#include<event2/listener.h>
#include <assert.h>
 
#define BUFLEN  1024

typedef struct _ConnectStat {
	//struct event*  ev;
	struct bufferevent* bev;
	char buf[BUFLEN];
}ConnectStat;

//echo 服务实现相关代码
ConnectStat * stat_init(int fd, struct bufferevent *bev);
 
void listener_cb(struct evconnlistener *listener, evutil_socket_t fd,  
                 struct sockaddr *sock, int socklen, void *arg); 
 
//accept_connection(int fd, short events, void* arg);
void do_echo_request(struct bufferevent* bev, void* arg);
void event_cb(struct bufferevent *bev, short event, void *arg);
//void do_echo_response(int fd, short events, void *arg);
 
int tcp_server_init(int port, int listen_num);

struct event_base* base;

int main(int argc, char** argv)
{
    struct sockaddr_in sin;  
    memset(&sin, 0, sizeof(struct sockaddr_in));  
    sin.sin_family = AF_INET;  
    sin.sin_port = htons(9999);  
  
    base = event_base_new();  
	
    struct evconnlistener *listener  
            = evconnlistener_new_bind(base, listener_cb, base,  
                                      LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE,  
                                      10, (struct sockaddr*)&sin,  
                                      sizeof(struct sockaddr_in));  
  
    event_base_dispatch(base);  
  
    evconnlistener_free(listener);
    event_base_free(base);
  
    return 0;  
}

ConnectStat * stat_init(int fd, struct bufferevent *bev) {
	ConnectStat * temp = NULL;
	temp = (ConnectStat *)malloc(sizeof(ConnectStat));

	if (!temp) {
		fprintf(stderr, "malloc failed. reason: %m\n");
		return NULL;
	}

	memset(temp, '\0', sizeof(ConnectStat));
	temp->bev = bev;

}
 
/*
一个新客户端连接上服务器此函数就会被调用,当此函数被调用时，libevent已经帮我们accept了这个客户端。
该客户端的文件描述符为fd
*/
void listener_cb(struct evconnlistener *listener, evutil_socket_t fd,  
                 struct sockaddr *sock, int socklen, void *arg)  
{  
    printf("accept a client %d\n", fd);  
  
    struct event_base *base = (struct event_base*)arg;  
  
    //为这个客户端分配一个bufferevent  
    struct bufferevent *bev =  bufferevent_socket_new(base, fd,  
                                               BEV_OPT_CLOSE_ON_FREE);
    ConnectStat *stat = stat_init(fd, bev);											   
  
    bufferevent_setcb(bev, do_echo_request, NULL, event_cb, stat);  
    bufferevent_enable(bev, EV_READ | EV_PERSIST);  
}  
 
 
void do_echo_request(struct bufferevent* bev, void* arg)
{
    
    ConnectStat *stat = (ConnectStat *)arg;
    char *msg = stat->buf;
    printf("do echo request ...\n");
	
	size_t len = bufferevent_read(bev, msg, BUFLEN);
 
    msg[len] = '\0';
    printf("recv from client<<<< %s\n", msg);
 
    bufferevent_write(bev, msg, strlen(msg));
	
   
}


void event_cb(struct bufferevent *bev, short event, void *arg)
{
	ConnectStat *stat = (ConnectStat *)arg;
 
    if (event & BEV_EVENT_EOF)
        printf("connection closed\n");
    else if (event & BEV_EVENT_ERROR)
        printf("some other error\n");
 
    //这将自动close套接字和free读写缓冲区
    bufferevent_free(bev);
	free(stat);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

注意: 如果执行代码报错:
./s2.exe: error while loading shared libraries: libevent-2.1.so.7: cannot open shared object file: No such file or director

1、问题描述
在使用libevent库编写服务端及客户端程序时，g++编译生成可执行文件后，运行该可执行文件出错。

2、产生原因及解决办法
产生原因：在运行时，程序无法找到libevent-2.1.so.7这个动态库，因为该动态库在默认安装时，存放的路径在/usr/local/lib下，不在系统的默认查找路径内。

解决办法：将该路径放在系统查找路径内。

第一步：
sudo echo “/usr/local/lib” >> /etc/ld.so.conf

若命令报错误
则可以使用vim或gedit打开/etc/ld.so.conf文件，在该文件末尾加上/usr/local/lib

第二步：

更新一下，使该配置生效

sudo ldconfig