// fork.c
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
int gval = 10;
int main(int argc, char* argv[])
{
int ival = 20;
pid_t pid = fork(); // 创建子进程
if( pid == 0)
gval+=2, ival +=2; // 子进程执行
else
gval-=2, ival -=2; // 父进程执行
if( pid ==0 )
printf("Child Proc:[%d, %d] \n", gval, ival); // 子进程执行
else
printf("Parent Proc:[%d, %d] \n", gval, ival); // 父进程执行
return 0;
}
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
void timeout(int sig)
{
if(sig == SIGALRM)
puts("Time out!");
alarm(2);
}
int main()
{
int i;
struct sigaction act;
act.sa_handler = timeout;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
sigaction(SIGALRM, &act, 0);
alarm(2);
for(i=0; i<3; ++i)
{
puts("wait...");
sleep(100);
}
return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/types.h>
#define BUF_SIZE 30
void err_sys(char *message);
void read_childproc(int sig);
int main(int argc, char* argv[])
{
int serv_sock, clnt_sock;
struct sockaddr_in serv_adr, clnt_adr;
pid_t pid;
struct sigaction act;
socklen_t adr_sz;
int str_len, state;
char buf[BUF_SIZE];
if(argc != 2)
{
printf("Usage : %s <port>\n", argv[0]);
exit(1);
}
act.sa_handler = read_childproc;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
state = sigaction(SIGCHLD, &act, 0);
serv_sock = socket(PF_INET, SOCK_STREAM, 0);
memset(&serv_adr, 0, sizeof(serv_adr));
serv_adr.sin_family = AF_INET;
serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_adr.sin_port = htons(atoi(argv[1]));
if(bind(serv_sock, (struct sockaddr*) &serv_adr, sizeof(serv_adr)) == -1)
err_sys("bind() error");
if(listen(serv_sock, 5) == -1)
err_sys("listen() error");
while(1)
{
adr_sz = sizeof(clnt_adr);
clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_adr, &adr_sz);
if(clnt_sock == -1)
continue;
else
puts("new client connected...");
pid = fork();
if(pid == -1)
{
close(clnt_sock);
continue;
}
if(pid == 0)
{
close(serv_sock);
while((str_len = read(clnt_sock, buf, BUF_SIZE)) != 0)
{
write(clnt_sock, buf, str_len);
}
close(clnt_sock);
puts("client disconnected...");
return 0;
}
else
close(clnt_sock);
}
close(serv_sock);
return 0;
}
void read_childproc(int sig)
{
pid_t pid;
int status;
pid = waitpid(-1, &status, WNOHANG);
printf("remove proc id: %d \n", pid);
}
void err_sys(char* message)
{
fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}
【服务器】
import socketserver
class MyServer(socketserver.BaseRequestHandler):
def handle(self):
# print self.request,self.client_address,self.server
conn = self.request
conn.sendall('请输入按键选择,0转人工服务.'.encode())
Flag = True
while Flag:
data = conn.recv(1024).decode()
if data == 'exit':
Flag = False
elif data == '0':
conn.sendall('通信可能会被记录...'.encode())
else:
conn.sendall('请重新输入.'.encode())
if __name__ == '__main__':
server = socketserver.ThreadingTCPServer(('127.0.0.1',8009),MyServer)
server.serve_forever()
【客户端】
import socket
import os
ip_port = ('127.0.0.1',9922)
sk = socket.socket()
sk.connect(ip_port)
container = {'key':'','data':''}
while True:
# 客户端输入要上传文件的路径
path = input('输入路径名：')
# 根据路径获取文件名
file_name = os.path.basename(path)
#print(file_name)
# 获取文件大小
file_size=os.stat(path).st_size
# 发送文件名 和 文件大小
Informf=(str(file_name)+'|'+str(file_size))
sk.send(Informf.encode())
# 为了防止粘包，将文件名和大小发送过去之后，等待服务端收到，直到从服务端接受一个信号（说明服务端已经收到）
sk.recv(1024)
send_size = 0
f= open(path,'rb')
Flag = True
while Flag:
if send_size + 1024 >file_size:
data = f.read(file_size-send_size)
Flag = False
else:
data = f.read(1024)
send_size+=1024
sk.send(data)
msg=sk.recv(1024)
print(msg.decode())
f.close()
os.system("start C:\\users\yyd\desktop\Send")
sk.close()
【服务器】
import socketserver
import os
class MyServer(socketserver.BaseRequestHandler):
def handle(self):
base_path = 'C:\\users\yyd\desktop\Send'
conn = self.request
print ('Connected to client')
print ('Upload waiting...')
while True:
pre_data = conn.recv(1024).decode()
#获取请求方法、文件名、文件大小
file_name,file_size = pre_data.split('|')
# 防止粘包，给客户端发送一个信号。
conn.sendall('nothing'.encode())
#已经接收文件的大小
recv_size = 0
#上传文件路径拼接
file_dir = os.path.join(base_path,file_name)
f = open(file_dir,'wb')
Flag = True
while Flag:
#未上传完毕，
if int(file_size)>recv_size:
#最多接收1024，可能接收的小于1024
data = conn.recv(1024)
recv_size+=len(data)
#写入文件
f.write(data)
#上传完毕，则退出循环
else:
recv_size = 0
Flag = False
msg="Upload successed."
print(msg)
conn.sendall(msg.encode())
f.close()
instance = socketserver.ThreadingTCPServer(('127.0.0.1',9922),MyServer)
instance.serve_forever()
package java.util;
import java.io.InvalidObjectException;
public class HashSet<E>
extends AbstractSet<E>
implements Set<E>, Cloneable, java.io.Serializable
{
static final long serialVersionUID = -5024744406713321676L;
private transient HashMap<E,Object> map;
// 空对象,放在map中的value位置
private static final Object PRESENT = new Object();
/**
*构造一个新的，空的HashSet,其底层 HashMap实例的默认初始容量是 16，加载因子是 0.75
*/
public HashSet() {
map = new HashMap<>();
}
/**
* 构造一个包含指定 collection 中的元素的新 set,容量为传入集合长度除以默认加载因子0.75 与默认初始化容量16的最大值
*/
public HashSet(Collection<? extends E> c) {
map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
addAll(c);
}
/**
* 构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和指定的加载因子
*/
public HashSet(int initialCapacity, float loadFactor) {
map = new HashMap<>(initialCapacity, loadFactor);
}
/**
*构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和默认的加载因子0.75
*/
public HashSet(int initialCapacity) {
map = new HashMap<>(initialCapacity);
}
/**
* Constructs a new, empty linked hash set. (This package private
* constructor is only used by LinkedHashSet.) The backing
* HashMap instance is a LinkedHashMap with the specified initial
* capacity and the specified load factor.
*
* @param initialCapacity the initial capacity of the hash map
* @param loadFactor the load factor of the hash map
* @param dummy ignored (distinguishes this
* constructor from other int, float constructor.)
* @throws IllegalArgumentException if the initial capacity is less
* than zero, or if the load factor is nonpositive
*/
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
map = new LinkedHashMap<>(initialCapacity, loadFactor);
}
/**
* 返回对此 set 中元素进行迭代的迭代器
*/
public Iterator<E> iterator() {
return map.keySet().iterator();
}
/**
* 获取数组个数,实际上是获取底层map中数据的个数
*/
public int size() {
return map.size();
}
/**
* 判断是否为空,实际上是判断map中的size是否等于0
*/
public boolean isEmpty() {
return map.isEmpty();
}
/**
* 是都包含某元素,实际上是判断是否包含key,因为set只有单值,所map中其实只用到了key,map为空对象
*/
public boolean contains(Object o) {
return map.containsKey(o);
}
/**
*调用map的put方法，其中value值为静态的Object对象
*/
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
/**
* 删除元素调用的是map的remove函数
*/
public boolean remove(Object o) {
return map.remove(o)==PRESENT;
}
/**
* 清空集合,调用的是map的clear()
*/
public void clear() {
map.clear();
}
/**
* 返回此 HashSet 实例的浅表副本
*/
@SuppressWarnings("unchecked")
public Object clone() {
try {
HashSet<E> newSet = (HashSet<E>) super.clone();
newSet.map = (HashMap<E, Object>) map.clone();
return newSet;
} catch (CloneNotSupportedException e) {
throw new InternalError(e);
}
}
}