GVKun编程网logo

PHP写时复制（Copy On Write）（php复制文件）

19

在本文中，我们将带你了解PHP写时复制在这篇文章中，我们将为您详细介绍PHP写时复制的方方面面，并解答CopyOnWrite常见的疑惑，同时我们还将给您一些技巧，以帮助您实现更有效的fork，写时复制

在本文中，我们将带你了解PHP写时复制在这篇文章中，我们将为您详细介绍PHP写时复制的方方面面，并解答Copy On Write常见的疑惑，同时我们还将给您一些技巧，以帮助您实现更有效的fork，写时复制(copy-on-write)，vfork、Java 写时拷贝容器 CopyOnWriteArrayList 的测试、Javascript 实现复制（Copy）、JAVA中写时复制Copy-On-Write。

本文目录一览：

PHP写时复制（Copy On Write）（php复制文件）

PHP写时复制（Copy On Write）（php复制文件）

从一个例子说起：

  
<?PHP
$foo = 1;
$bar = $foo;
echo $foo + $bar;

变量 foo 赋值给变量foo赋值给变量bar，这两个变量具有相同的值，没有必要新申请内存空间，他们可以共享同一块内存。在很多场景下PHP 的 COW 对内存进行优化。比如：变量的多次赋值、函数参数传递，并在函数体内修改实参等。

什么是“复制”

这是一段摘自鸟哥博客的例子，说的比较清楚，就直接贴过来了。

<?PHP
   $var = "laruence";
   $var_dup = $var;
   $var = 1;
?>

很明显在这段代码执行以后，$var_dup 的值应该还是”laruence”, 那么这又是怎么实现的呢？这就是 PHP 的 copy on write 机制：

PHP 在修改一个变量以前，会首先查看这个变量的 refcount，如果 refcount 大于1，PHP 就会执行一个分离的例程， 对于上面的代码，当执行到第三行的时候，PHP 发现 var 指向的 zval 的 refcount 大于1，那么 PHP 就会复制一个新的 zval 出来，将原 zval 的 refcount 减 1，并修改 symbol_table，使得var指向的zval的refcount大于1，那么PHP就会复制一个新的zval出来，将原zval的refcount减1，并修改symbolt​able，使得var 和 $var_dup 分离(Separation)。这个机制就是所谓的 copy on write(写时复制)。

写时复制应用场景

写时复制（copy on Write，也缩写为COW)的应用场景非常多， 比如Linux中对进程复制中内存使用的优化，在各种编程语言中，如C++的STL等等中均有类似的应用。 COW是常用的优化手段，可以归类于：资源延迟分配。只有在真正需要使用资源时才占用资源， 写时复制通常能减少资源的占用。

一个证明 PHP COW 优化内存占用的例子：

<?PHP
$j = 1;
var_dump(memory_get_usage());
 
$tipi = array_fill(0, 100000, 'PHP-internal');
var_dump(memory_get_usage());
 
$tipi_copy = $tipi;
var_dump(memory_get_usage());
 
foreach ($tipi_copy as $i) {
    $j += count($i);
}
var_dump(memory_get_usage());

运行结果：

$ PHP t . PHP
int(630904)
int(10479840)
int(10479944)
int(10480040)

内存并没有显著提高。

“写时复制”的原理

多个相同值的变量共用同一块内存的确节省了内存空间，但变量的值是会发生变化的，如果在上面的例子中， 指向同一内存的值发生了变化（或者可能发生变化），就需要将变化的值“分离”出去，这个“分离”的操作， 就是“复制”。

在PHP中，Zend引擎为了区别同一个zval地址是否被多个变量共享，引入了ref_count和is_ref两个变量进行标识：

ref_count和is_ref是定义于zval结构体中

is_ref标识是不是用户使用 & 的强制引用；

ref_count是引用计数，用于标识此zval被多少个变量引用，即COW的自动引用，为0时会被销毁；

注：由此可见， a=a=b; 与 a=&b; 在PHP对内存的使用上没有区别（值不变化时）；

相信大家也可以了解到PHP中COW的实现原理： PHP 中的 COW 基于引用计数ref_count 和 is_ref 实现， 多一个变量指针，就将 ref_count 加 1， 反之减去 1，减到 0 就销毁； 同理，多一个强制引用 &,就将 is_ref 加 1，反之减去 1

 

转载: https://segmentfault.com/a/1190000014024336

fork，写时复制(copy-on-write)，vfork

fork，写时复制(copy-on-write)，vfork

fork，写时复制(copy-on-write)，vfork

aque  fork  vfork  写时复制 

进程创建

进程创建分为三种情况
1.共享
父进程与子进程共享数据段、堆栈段、代码段，也就是说子进程对数据进行的改变会直接影响父进程。
2.写时复制(Copy-On-Write)
我简单地将这种技术理解为，当子进程执行写操作时，内核会将被修改的部分单独copy，单独操作。
3.直接拷贝
直接复制父进程的数据段、堆栈段，共享代码段。

一、fork

fork()调用时，子进程会复制父进程数据段、堆栈段，并且使用新的物理地址以及虚拟地址存储。但父子进程共享代码段。但现在的实现采用了写时复制技术。

二、vfork

vfork()调用时，父子进程共享所有资源。但在调度上，使用vfork将保证子进程先于父进程被调度。

下面给出参考书的代码用以说明两者区别：

  • fork
	/**********************************************************************

		> File Name: t_fork.c

		> Author: 0nism

		> Email: fd98shadow@sina.com

		> Created Time: Sun 14 Oct 2018 02:41:39 PM CST

	***********************************************************************/

	#include <unistd.h>
	#include <stdio.h>
	#include <stdlib.h>

	static int idata = 111;         //  Allocated in data segment

	int main(int argc, char **argv)
	{
		int istack = 222;           //  Allocated in stack segment
		pid_t childPid;

		switch (childPid = fork())
		{   
			case -1: 
					printf("err: fork\n");
					return 0;

			case 0:
					idata *= 3;
					istack *= 3;
					break;

			default:
					sleep(3);
					break;
		}   

		printf("PID=%ld %s idata=%d istack=%d\n", (long)getpid(),
						(childPid == 0) ? "child " : "parent ", idata, istack);

		exit(EXIT_SUCCESS);
	}

运行结果为

	MISlike@10:56:~/process $ ./t_fork 
	PID=5566 child  idata=333 istack=666
	PID=5565 parent  idata=111 istack=222

无论是数据段还是堆栈段均完成了复制。

  • vfork
	/**********************************************************************

		> File Name: t_vfork.c

		> Author: 0nism

		> Email: fd98shadow@sina.com

		> Created Time: Sun 14 Oct 2018 11:21:22 PM CST

	***********************************************************************/

	#include <unistd.h>
	#include <stdio.h>
	#include <stdlib.h>

	int main(int argc, char **argv)
	{
		int istack = 222;

		switch (vfork())
		{   
			case -1: 
					printf("err: vfork\n");
					return 0;

			case 0:                 //  子进程优先执行，在父进程的虚拟地址空间中
					sleep(3);       //  即使休眠一段时间，父进程仍然不会先执行

					write(STDOUT_FILENO, "Child excuting\n", 16);
					istack *= 3;    //  这个变化将会被父进程知晓
					_exit(EXIT_SUCCESS);

			default:                //  父进程被锁住直到子进程消亡
					write(STDOUT_FILENO, "Parent excuting\n", 16);
					printf("istack = %d\n", istack);
					_exit(EXIT_SUCCESS);

		}   
	}

运行结果如下

Child excuting
Parent excuting
istack = 666

可见子进程操作影响到了父进程，且此时父进程被阻塞，知道子进程消亡或者执行excu()。

Java 写时拷贝容器 CopyOnWriteArrayList 的测试

Java 写时拷贝容器 CopyOnWriteArrayList 的测试

测试代码：

package copyOnWriteArrayListTest;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class AddThread implements Runnable {
   
   
   
    private List<Double> list;
    public AddThread(List<Double> list) {
   
   
   
        this.list = list;
   }
  
  @Override
   public void run(){
   
   
   
      for ( int i = 0; i < 10000; i++){
   
   
   
        list.add(Math.random());
      }
   }
}

public class CopyOnWriteArrayListTest {
   
   
   

	public static final int THREAD_POOL_SIZE = 2;
	
	public static void main(String[] args) throws InterruptedException {
   
   
   
		// List<Double> list = new ArrayList<>();
		List<Double> list = new CopyOnWriteArrayList<>();
		ExecutorService es = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
		es.execute(new AddThread(list));
		es.execute(new AddThread(list));
		
		es.shutdown();
		
		Thread.sleep(4000);
		System.out.println("OK, list length: " + list.size());

	}

}

输出结果：

OK, list length: 20000

如果把支持写时拷贝的 list 替换成普通的 ArrayList：

List list = new ArrayList<>();

因为两个线程同时对这个普通的 ArrayList 进行写操作，结果如下：

OK, list length: 17578

看下 CopyOnWriteArrayList 实现源代码里 Add 方法的实现：

/**
     * Appends the specified element to the end of this list.
     *
     * @param e element to be appended to this list
     * @return {@code true} (as specified by {@link Collection#add})
     */
    public boolean add(E e) {
   
   
   
        synchronized (lock) {
   
   
   
            Object[] es = getArray();
            int len = es.length;
            es = Arrays.copyOf(es, len + 1);
            es[len] = e;
            setArray(es);
            return true;
        }
    }

lock 初始化的地方：

final transient Object lock = new Object();

本文分享 CSDN - 汪子熙。
如有侵权，请联系 support@oschina.cn 删除。
本文参与 “OSC 源创计划”，欢迎正在阅读的你也加入，一起分享。

Javascript 实现复制（Copy）

Javascript 实现复制（Copy）

<table><tr>
<td><pre>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

要做一个使用js复制文本的需求，据说之前要用到flash的，百度了一下，这篇文章的第一个就好用，赶快记录下来   实现点击按钮，复制文本框中的的内容 -------------------   试过了，好用           文章来源：http://www.jb51.cc/article/51321.htm  

总结

以上是小编为你收集整理的Javascript 实现复制（Copy）全部内容。

如果觉得小编网站内容还不错，欢迎将小编网站推荐给好友。

JAVA中写时复制Copy-On-Write

JAVA中写时复制Copy-On-Write

点击上方「蓝字」关注我们

0x01: 什么是写时复制(Copy-On-Write)容器？

写时复制是指：在并发访问的情景下，当需要修改JAVA中Containers的元素时，不直接修改该容器，而是先复制一份副本，在副本上进行修改。修改完成之后，将指向原来容器的引用指向新的容器(副本容器)。

 

0x02: 写时复制带来的影响

  • 由于不会修改原始容器，只修改副本容器。因此，可以对原始容器进行并发地读。其次，实现了读操作与写操作的分离，读操作发生在原始容器上，写操作发生在副本容器上。

  • 数据一致性问题：读操作的线程可能不会立即读取到新修改的数据，因为修改操作发生在副本上。但最终修改操作会完成并更新容器，因此这是最终一致性。

 

0x03: 在JDK中提供了CopyOnWriteArrayList类和CopyOnWriteArraySet类，但是并没有提供CopyOnWriteMap的实现。因此，可以参考CopyOnWriteArrayList自己实现一个CopyOnWriteHashMap

主要是在写操作时，如何保证线程安全即可。

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class CopyOnWriteMap<K, V> implements Map<K, V>, Cloneable{

    private volatile Map<K, V> internalMap;

    public CopyOnWriteMap() {
        internalMap = new HashMap<K, V>(100);//初始大小应根据实际应用来指定
    }

    @Override
    public V put(K key, V value) {
        synchronized (this) {
            Map<K, V> newMap = new HashMap<K, V>(internalMap);//复制出一个新HashMap
            V val = newMap.put(key, value);//在新HashMap中执行写操作
            internalMap = newMap;//将原来的Map引用指向新Map
            return val;
        }
    }

    @Override
    public void putAll(Map<? extends K, ? extends V> m) {
        synchronized (this) {
            Map<K, V> newMap = new HashMap<K, V>(internalMap);
            newMap.putAll(m);
            internalMap = newMap;
        }
    }

    @Override
    public V get(Object key) {
        V result = internalMap.get(key);
        return result;
    }
    ......//other methods inherit from interface Map
}

从上可以看出，对于put() 和 putAll() 而言，需要加锁。而读操作则不需要，如get(Object key)。这样，当一个线程需要put一个新元素时，它先锁住当前CopyOnWriteMap对象，并复制一个新HashMap，而其他的读线程因为不需要加锁，则可继续访问原来的HashMap。

这里加锁使用synchronized关键字；其实也可以使用ReentrantLock对象。官方对synchronized的优化，已经使得synchronized不在一直是重量级；而是满足某种情况才升级为重量级锁。

 

0x04: 应用场景

CopyOnWrite容器适用于读多写少的场景。因为写操作时，需要复制一个容器，造成内存开销很大，也需要根据实际应用把握初始容器的大小。

不适合于数据的强一致性场合。若要求数据修改之后立即能被读到，则不能用写时复制技术。因为它是最终一致性。

总结：写时复制技术是一种很好的提高并发性的手段。

 

0x0５：为什么会出现Copy-On-Write？

集合类(ArrayList、HashMap)上的常用操作是：向集合中添加元素、删除元素、遍历集合中的元素然后进行某种操作。当多个线程并发地对一个集合对象执行这些操作时就会引发ConcurrentModificationException，比如线程A在for-each中遍历ArrayList，而线程B同时又在删除ArrayList中的元素，就可能会抛出ConcurrentModificationException，可以在线程A遍历ArrayList时加锁，但由于遍历操作是一种常见的操作，加锁之后会影响程序的性能，因此for-each遍历选择了不对ArrayList加锁而是当有多个线程修改ArrayList时抛出ConcurrentModificationException，因此，这是一种设计上的权衡。

为了应对多线程并发修改这种情况，一种策略就是本文的主题“写时复制”机制；另一种策略是：线程安全的容器类：

ArrayList--->CopyOnWriteArrayList
HashMap--->ConcurrentHashMap

而ConcurrentHashMap并不是从“复制”这个角度来应对多线程并发修改，而是引入了分段锁(JDK7)；CAS、锁(JDK11)解决多线程并发修改的问题。

扫码二维码

获取更多精彩

Java乐园

有用！分享+在看☟

本文分享自微信公众号 - JAVA乐园（happyhuangjinjin88）。
如有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一起分享。

关于PHP写时复制和Copy On Write的介绍已经告一段落，感谢您的耐心阅读，如果想了解更多关于fork，写时复制(copy-on-write)，vfork、Java 写时拷贝容器 CopyOnWriteArrayList 的测试、Javascript 实现复制（Copy）、JAVA中写时复制Copy-On-Write的相关信息，请在本站寻找。

本文标签：

上一篇使用 phpStudy2016 部署本地 Think PHP 3.2.3（phpstudy部署php项目）

下一篇php 二维数组转一维数组小结（php二维数组转化成一维数组）

相关文章