内存复制-Marshal.Copy：

 // 复制当前传入的数据
 byte[] pcm_src = new byte[len];
 // 复制数据到二进制数组
 Marshal.Copy(pcm, pcm_src, 0, len);

数组复制-Array.Copy：

// 复制当前传入的数据
byte[] pcm_src = new byte[len];
// 复制数据到二进制数组
Marshal.Copy(pcm, pcm_src, 0, len);
// 复制新传入的数据到新的数组结构
Array.Copy(pcm_src, 0, pcm_dest, bts_left.Length, len)

测试示例：

        // 采样数
        ushort samples = 320;

        // 上次剩余的字节
        byte[] bts_left;

        class aa
        {
            public byte[] pcm;
            public int len;
        }

        private List<aa> data = new List<aa>();
    
        public void PlayAudio(IntPtr pcm, int len)
        {
            lock (this)
            {
                int samples_len = samples * 2;

                if (len == samples_len)
                {
                    byte[] bts = new byte[len];
                    Marshal.Copy(pcm, bts, 0, len);
                    data.Add(new aa
                    {
                        len = len,
                        pcm = bts
                    });
                }
                else
                // 此处解决采样数为1024时分割可以复制数据的大小
                {
                    var len_temp = bts_left ==null? len : len + bts_left.Length;

                    byte[] pcm_dest = new byte[len_temp];
                    byte[] bts = new byte[samples_len];
                    // 复制数据
                    if (bts_left != null)
                    {
                        // 复制长度不够的数据
                        Array.Copy(bts_left,0, pcm_dest, 0, bts_left.Length);
                        // 复制当前传入的数据
                        byte[] pcm_src = new byte[len];
                        // 复制数据到二进制数组
                        Marshal.Copy(pcm, pcm_src, 0, len);
                        // 复制新传入的数据到新的数组结构
                        Array.Copy(pcm_src, 0, pcm_dest, bts_left.Length, len);
                       
                        bts_left = null;
                    }
                    else
                    {
                        Marshal.Copy(pcm, pcm_dest, 0, len_temp);
                    }
                    // 获取播放数据
                    int index = 0,count= len_temp / samples_len;
                    int startIndex=0;
                    Console.WriteLine(">>>total:"+ len_temp + ",times:" + count + ",left:" + len_temp % samples_len);
                    while (index< count)
                    {
                        // 复制满足长度的数据
                        Array.Copy(pcm_dest, startIndex, bts, 0, samples_len);
                        // 添加数据
                        data.Add(new aa
                        {
                            len = samples_len,
                            pcm = bts
                        });
                        index++;
                        // 计算下一次的开始位置
                        startIndex = index * samples_len; 
                    }
                    // 暂存长度不够的数据
                    var left_len = len_temp % samples_len;
                    if (left_len > 0)
                    {
                        bts_left = new byte[left_len];
                        // 复制不够长度的数据
                        Array.Copy(pcm_dest, startIndex, bts_left, 0, left_len);
                    }
                }
            }

            //SDL.SDL_Delay(10);
        }

比较好奇python对于多进程中copy on write机制的实际使用情况。目前从实验结果来看，python 使用multiprocessing来创建多进程时，无论数据是否不会被更改，子进程都会复制父进程的状态(内存空间数据等)。所以如果主进程耗的资源较多时，不小心就会造成不必要的大量的内存复制，从而可能导致内存爆满的情况。

示例

举个例子，假设主进程读取了一个大文件对象的所有行，然后通过multiprocessing创建工作进程，并循环地将每一行数据交给工作进程来处理：

def parse_lines(args):
    #working
    ...

def main_logic():
    f = open(filename , 'r')
    lines = f.readlines()
    f.close()
    pool = multiprocessing.Pool(processes==4)
    rel = pool.map(parse_lines , itertools.izip(lines , itertools.repeat(second_args)) , int(len(lines)/4))
    pool.close()
    pool.join()

以下是top及ps结果：

(四个子进程)

(父进程及四个子进程)

由上两张图可以看出父进程及子进程都各自占用了1.4G左右的内存空间。而大部分内存空间存储的是读数据lines，所以这样的内存开销太浪费。

优化计划

1: 在主进程初期未导入大量的py库之前创建进程，或者动态加载py库。

2:通过内存共享来减少内存的开销。

3: 主进程不再读取文件对象，交给每个工作进程去读取文件中的相应部分。

改进代码：

def line_count(file_name):
    count = -1 #让空文件的行号显示0
    for count,line in enumerate(open(file_name)): pass
    #enumerate格式化成了元组,count就是行号,因为从0开始要+1
    return count+1

def parse_lines(args):
    f = open(args[0] , 'r')
    lines = f.readlines()[args[1]:args[2]] #read some lines
    f.close()   
    #working

def main_logic(filename,process_num):
    line_count = line_count(filename)
    avg_len = int(line_count/process_num)
    left_cnt = line_count%process_num;

    pool = multiprocessing.Pool(processes=process_num)
    for i in xrange(0,process_num):
        ext_cnt = (i>=process_num-1 and [left_cnt] or [0])[0]
        st_line = i*avg_len
        pool.apply_async(parse_lines, ((filename, st_line, st_line+avg_len+ext_cnt),))  #指定进程读某几行数据
    pool.close()
    pool.join()

再次用top或者ps来查看进程的内存使用情况：

(四个子进程)

(父进程及四个子进程)

小结

对比两次的内存使用情况，改进代码后父进程及子进程所占用的内存明显减少；所有内存占用相当于原来的一半，这就是减少内存复制的效果。

关于内存使用这方面还有不少优化方法和空间，稍后继续研究。

memcpy 也就是memory和copy的简写。

memcpy实现的功能：从一个指针所指向的地址作为开始，复制一定大小的内容，给另一个指针所指向的地址。

代码：

#include <iostream>
#include <cstring>
using namespace std;
int main()
{
	int *p = new int[5];
	for (int i = 0; i < 5; i++)
	{
		p[i] = i;
	}
	int *p2 = new int[5];
	memcpy(p2, p,5*sizeof(int));//从p指向的内存复制  5*sizeof(int)大小的内容 给p2所指向的内存
	for(int i = 0;i<5;i++)
	{
		cout << p2[i] << endl;
	}
	system("pause");
	return 0;
}
/*
void* __cdecl memcpy(
_Out_writes_bytes_all_(_Size) void* _Dst,        //destination目的地
_In_reads_bytes_(_Size)       void const* _Src,  //source 源头
_In_                          size_t      _Size  //空间大小
		    )
*/