精华内容
下载资源
问答
  • 码-源码

    2021-02-12 13:04:54
    要了解有关Next.js的更多信息,请查看以下资源: -了解Next.js功能和API。 交互式Next.js教程。 您可以查看-欢迎您提供反馈和意见! 在Vercel上部署 部署Next.js应用程序的最简单方法是使用Next.js创建者提供的。...
  • pandas生成虚拟变量(变量) import pandas as pd import numpy as np data = pd.read_csv('train.csv') data.Department Department 代表员工所在部门,Sales销售部,Research & Development研发部,Human ...

    pandas将分类变量转化为虚拟变量(哑变量)

    import pandas as pd
    import numpy as np
    data = pd.read_csv('train.csv')
    data.Department
    

    Department 代表员工所在部门,Sales销售部,Research & Development研发部,Human Resources人力资源部

    在这里插入图片描述

    下面将其转化为虚拟变量或者one-hot编码

    Department_dummy= pd.get_dummies(data['Department'],drop_first=False,prefix='Department')
    Department_dummy.head()
    

    在这里插入图片描述
    prefix 代表生成的dummy变量命名前缀,drop_first是剔除第一类的列,因为排除其他类别剩下的类别就是第一类(一般用于解决回归分析中的多重共线性问题)。

    下面的一行代码用于将虚拟变量和原始变量,拼在一起(类似矩阵分块,左边一块右边一块),用于建模分析。

    train=pd.concat([Department_dummy,data],axis=1)
    
    展开全文
  • 包括标准库类型在内的许多C++类都有定义良好的析构函数,负责清理对象使用的资源。直接看这个例子,下面的程序有可能出现在C语言和C++语言混合使用的网络库,因为C语言没有析构函数概念,所以没有定义析构函数,而是...

    包括标准库类型在内的许多C++类都有定义良好的析构函数,负责清理对象使用的资源。直接看这个例子,下面的程序有可能出现在C语言和C++语言混合使用的网络库,因为C语言没有析构函数概念,所以没有定义析构函数,而是使用函数来释放对象。

    struct destination; //要连接的对象
    struct connection;  //表示此次连接
    connection connect(destination * d);//调用connect将返回一个与destination的一个连接对象
    void disconnect(connection);//断开连接的方法
    

    我们可能在某个函数中使用这个库:

    void fun(destination &d)//传入一个引用
    {
    	connection c=connect(&d);//建立连接并
    	//使用这个连接
    	//忘记调用disconnect释放连接资源 
    	//connection c局部对象在函数离开后再也找不到了
    	//连接没有办法断开了
    }
    

    这是用可以使用智能指针构造重载形式:shared_ptr<T> p(q,d),将d对象定义中加入disconnect,控制其析构。简单来说就是兼容不写析构函数的C。

    展开全文
  • ODN属于无源网络,目前管理手段却相对简单,即利用存量管理系统进行ODN管道资源信息的管理(哑资源管理),并在业务开通、维护的
  • C++ 资源管理

    2021-02-04 08:41:54
    目录资源管理以对象管理资源行为像值的类行为像指针的类引用计数定义一个使用引用计数的类智能指针 和 资源管理智能指针 和 异常智能指针 和 类实例:动态内存管理类`StrBlob` 类核查指针类`StrVec` 类`StrVec` 类...

    本文参考 C++ PrimerC++\ Primer, Effective C++Effective\ C++

    资源管理

    • 所谓资源就是,一旦用了它,将来必须还给系统。如果不这样,糟糕的事情就会发生
      • C++程序中最常使用的资源就是动态分配内存(如果你分配内存却从来不曾归还它,会导致内存泄漏)。其他常见的资源还包括文件描述器(file descriptors) 、互斥锁(mutex locks) 、图形界面中的字型和笔刷、数据库连接、以及网络sockets

    异常安全

    异常安全函数

    异常安全函数 (Exception-safe functions) 提供以下三个保证之一:

    • 基本承诺:如果异常被抛出,程序内的任何事物仍然保持在有效状态下。所有对象都处于一种内部前后一致的状态。然而程序的实际状态恐怕不可预料。例如,对象的状态可能是一个缺省状态,也可能保持原状态
    • 强烈保证:如果函数失败(抛出异常),程序会回复到 “调用函数之前” 的状态
    • 不抛掷 (nothrow) 保证,承诺绝不抛出异常,因为它们总是能够完成它们原先承诺的功能。作用于内置类型的所有操作都提供 nothrow 保证

    copy and swap

    • copy and swap: 为你打算修改的对象(原件)做出一份副本,然后在那副本身上做一切必要修改。若有任何修改动作抛出异常,原对象仍保持未改变状态。待所有改变都成功后,再将修改过的那个副本和原对象在一个不抛出异常的操作中置换 (swap)
    • copy and swap 可提供“异常安全”的 强烈保证

    以对象管理资源

    • 把资源放进对象内,我们便可依赖 C++ 的析构函数来确保资源被释放;也可使用智能指针来管理资源

    如果用智能指针来管理资源,那么类中甚至都不需要析构函数;可以给智能指针提供自定义的删除器来自定义释放资源的操作


    • 通常, 管理类外资源的类需要通过析构函数来释放对象所分配的资源。一旦一个类需要析构函数, 那么它几乎肯定也需要拷贝构造函数和拷贝赋值运算符
    • 为了定义拷贝成员, 我们首先必须确定此类型对象的拷贝语义
      • 类值对象:当我们拷贝一个像值的对象时,副本和原对象是完全独立的
      • 类指针对象:行为像指针的类则共享状态。当我们拷贝一个这种类的对象时, 副本和原对象使用相同的底层数据

    行为像值的类

    class HasPtr {
    public:
    	HasPtr(const std::string &s = std::string()) :
    		ps(new std::string(s)), i(0) {}
    	// 对 ps 指向的 string, 每个 HasPtr 对象都有自己的拷贝
    	HasPtr(const HasPtr &p):	
    		ps(new std::string(*p.ps)), i(p.i) {}
    	HasPtr& operator=(const HasPtr &);
    	~HasPtr() { delete ps; }
    private:
    	std::string *ps;	// 管理的资源为 string
    	int i;
    }
    
    HasPtr& HasPtr::operator=(const HasPtr &rhs)
    {
    	// 通过先拷贝右侧运算对象来处理自赋值情况,同时代码也是“异常安全”的
    	auto newp = new string(*rhs.ps); // 拷贝底层 string
    	delete ps; // 释放旧内存
    	ps = newp;
    	i = rhs.i;
    	return *this;
    }
    

    行为像指针的类

    • 对于行为类似指针的类, 我们需要为其定义拷贝构造函数和拷贝赋值运算符来拷贝指针成员本身而不是它指向的string
    • 我们的类仍然需要自己的析构函数来释放接受string 参数的构造函数分配的内存。但是, 在本例中, 析构函数不能单方面地释放关联的string只有当最后一个指向stringHasPtr 销毁时, 它才可以释放string
      • 最好的解决方法是使用shared_ptr 来管理类中的资源。拷贝(或赋值) 一个shared_ptr 会拷贝(赋值) shared_ptr 所指向的指针。当没有用户使用对象时,shared_ptr 类负责释放资源
      • 但是, 有时我们希望直接管理资源。在这种情况下,使用 引用计数(reference count) 就很有用了

    引用计数

    • 除了初始化对象外, 每个构造函数(拷贝构造函数除外)还要创建一个引用计数,用来记录有多少对象与正在创建的对象共享状态。当我们创建一个对象时,计数器初始化为 1
    • 拷贝构造函数不分配新的计数器, 而是拷贝给定对象的数据成员, 包括计数器。拷贝构造函数递增共享的计数器, 指出给定对象的状态又被一个新用户所共享
    • 析构函数递减计数器, 指出共享状态的用户少了一个。如果计数器变为 0, 则析构函数释放状态
    • 拷贝赋值运算符递增右侧运算对象的计数器, 递减左侧运算对象的计数器。如果左侧运算对象的计数器变为 0, 意味着它的共享状态没有用户了, 拷贝赋值运算符就必须销毁状态

    • 唯一的难题是确定在哪里存放引用计数。一种方法是将计数器保存在动态内存中。当创建一个对象时, 我们也分配一个新的计数器。当拷贝或赋值对象时, 我们拷贝指向计数器的指针。使用这种方法,副本和原对象都会指向相同的计数器

    定义一个使用引用计数的类

    class HasPtr {
    public:
    	// 构造函数分配新的 string 和新的计数器, 将计数器置为 1
    	HasPtr(const std::string &s = std::string()):
    		ps(new std::string(s)), i(0), use(new std::size_t(1)) {}
    	// 拷贝构造函数拷贝所有三个数据成员, 并递增计数器
    	HasPtr(const HasPtr &p):
    		ps(p.ps), i(p.i), use(p.use) { ++*use; }
    	HasPtr& operator= (const HasPtr&);
    	~HasPtr();
    private:
    	std::string *ps;
    	int i;
    	std::size_t *use; // 用来记录有多少个对象共享 *ps 的成员
    };
    
    HasPtr::~HasPtr()
    {
    	if (--*use == 0) { 	// 如果引用计数变为0
    		delete ps; 		// 释放string内存
    		delete use; 	// 释放计数器内存
    	}
    }
    
    HasPtr& HasPtr::operator=(const HasPtr &rhs)
    {
    	++*rhs.use; 		// 递增右侧运算对象的引用计数
    	if (--*use == 0) { 	// 然后递减本对象的引用计数
    		delete ps; 
    		delete use; 
    	}
    	ps = rhs.ps;
    	i = rhs.i;
    	use = rhs.use;
    	return *this;
    }
    

    补充:练习13.28

    智能指针 和 资源管理

    智能指针 和 异常

    • 使用异常处理的程序能在异常发生后令程序流程继续,我们注意到, 这种程序需要确保在异常发生后资源能被正确地释放。一个简单的确保资源被释放的方法是使用智能指针
      • 如果使用智能指针, 即使程序块过早结束, 智能指针类也能确保在内存不再需要时将其释放 (因为一定会调用其析构函数)
      • 与之相对的, 当发生异常时, 我们直接管理的内存是不会自动释放的
    void f()
    {
    	shared_ptr<int> sp(new int(42)); //分配一个新对象
    	// 这段代码抛出一个异常, 且在f中未被捕荻

    智能指针 和 哑类

    • 包括所有标准库类在内的很多C++类都定义了析构函数,负责清理对象使用的资源。但是,不是所有的类都是这样良好定义的。特别是那些为C和C++两种语言设计的类, 通常都要求用户显式地释放所使用的任何资源
    • 那些分配了资源, 而又没有定义析构函数来释放这些资源的类, 可能会遇到与使用动态内存相同的错误:程序员非常容易忘记释放资源。类似的, 如果在资源分配和释放之间发生了异常, 程序也会发生资源泄漏
    • 与管理动态内存类似,我们通常可以使用智能指针来管理不具有良好定义的析构函数的类

    • 例如,假定我们正在使用一个C和C++都使用的网络库,使用这个库的代码可能是这样的:
    struct destination; 	// 表示我们正在连接什么
    struct connection; 		// 使用连接所需的信息
    connection connect(destination*); 	// 打开连接
    void disconnect(connection);	 	// 关闭给定的连接
    void f(destination &d) 
    {
    	// 获得一个连接;记住使用完后要关闭它
    	connection c = connect(&d);
    	// 使用连接
     	// 如果我们在 f 退出前忘记调用 disconnect, 就无法关闭 c 了
    }
    
    • 如果connection有一个析构函数, 就可以在f结束时由析构函数自动关闭连接。但是,connection没有析构函数。使用shared_ptr来保证connection被正确关闭, 已被证明是一种有效的方法
    • 为了用shared_ptr来管理一个connection, 我们必须首先定义一个函数来代替delete。这个删除器(deleter)函数必须能够完成对shared_ptr中保存的指针进行释放的操作。在本例中, 我们的删除器必须接受单个类型为connection*的参数:
    void end_connection(connection *p) { disconnect(*p); }
    
    • 当我们创建一个shared_ptr时, 可以传递一个(可选的) 指向删除器函数的参数:
    void f(destination &d)
    {
    	connection c = connect(&d);
    	shared_ptr<connection> p(&c, end_connection);
    }
    

    实例:动态内存管理类

    • 某些类需要在运行时分配可变大小的内存空间。这种类通常可以使用标准库容器来保存它们的数据。但是, 某些类需要自己进行内存分配。这些类一般来说必须定义自己的拷贝控制成员来管理所分配的内存

    StrBlob

    模板类 Blob 可参考这里

    • 现在我们先定义一个管理string的类, 此版本命名为StrBlob。它使用动态内存来让多个对象能共享相同的底层数据。在本例中,我们将使用vector来保存元素
      • 但是,我们不能在一个Blob对象内直接保存vector, 因为一个对象的成员在对象销毁时也会被销毁。例如,假定b1b2是两个Blob对象, 共享相同的vector 。如果此vector保存在其中一个Blob中,那么当b2离开作用域时,此vector也将被销毁。为了保证vector中的元素继续存在,我们将vector保存在动态内存中
      • 为了实现我们所希望的数据共享,我们为每个StrBlob设置一个shared_ptr来管理动态分配的vector
    class StrBlob {
    public:
    	typedef std::vector<std::string>::size_type size_type;
    	
    	// 默认构造函数分配一个空 `vector`
    	StrBlob() : data(std::make_shared<std::vector<std::string>>()) { }
    	// 支持用列表初始化
    	StrBlob(std::initializer_list<std::string> il): 
    				data(std::make_shared<std::vector<std::string>>(il)) { }
    	
    	size_type size() const { return data->size(); }
    	bool empty() const { return data->empty(); }
    	
    	// 添加和删除元素
    	void push_back(const std::string &t) { data->push_back(t);void pop_back();	// 需要检查元素个数,若为空则抛出异常
    	
    	// 元素访问,若为空则抛出异常
    	std::string& front();
    	std::string& back();
    private:
    	std::shared_ptr<std::vector<std::string>> data;	// 指向共享资源
    	// 作为 pop_back、front、back 共用的工具函数,检查一个给定索引是否在合法范围内
    	// 如果 data[i] 不合法, 抛出一个异常 (msg 用来描述错误内容)
    	void check(size_type i, const std::string &msg) const;
    )
    void StrBlob::check(size_type i, const string &msg) const
    {
    	if (i >= data->size())
    		throw out_of_range(msg);
    }
    
    string& StrBlob::front()
    {
    	// 如果vector为空, check会抛出一个异常
    	check(0, "front on empty StrBlob");
    	return data->front();
    }
    
    string& StrBlob::back()
    {
    	check(0, "back on empty StrBlob");
    	return data->back();
    }
    
    void StrBlob::pop_back()
    {
    	check(0, "pop_back on empty StrBlob");
    	data->pop_back();
    }
    

    核查指针类

    • StrBlobPtr 会保存一个 weak_ptr, 指向 StrBlobdata 成员,这是初始化时提供给它的。通过使用 weak_ptr, 不会影响一个给定的 StrBlob 所指向的vector的生存期。但是, 可以阻止用户访问一个不再存在的 vector 的企图

    StrBlobPtr会有两个数据成员

    • wptr, 或者为空, 或者指向一个StrBlob 中的vector
    • curr, 保存当前对象所表示的元素的下标。类似它的伴随类 StrBlob, 我们的指针类也有一个 check 成员来检查解引用 StrBlobPtr 是否安全:
    class StrBlobPtr {
    public:
    	// 将 curr 显式初始化为 0, 并将 wptr 隐式初始化为一个空 weak_ptr
    	StrBlobPtr(): curr(0) {}
    	// 接受一个 StrBlob 引用和一个可选的索引值
    	StrBlobPtr(StrBlob &a, size_t sz = 0):
    				wptr(a.data), curr(sz) {}
    				
    	std::string& deref() const;	// 解引用
    	StrBlobPtr& incr(); 		// 前缀递增
    private:
    	// 若检查成功,check 返回一个指向 vector 的 shared_ptr
    	std::shared_ptr<std::vector<std::string>>
    		check(std::size_t, const std::string&) const;
    	// 保存一个 weak_ptr, 意味着底层 vector 可能会被销毁
    	std::weak_ptr<std::vector<std::string>> wptr;
    	std::size_t curr; // 在数组中的当前位置 (下标)
    };
    

    值得注意的是, 我们不能将 StrBlobPtr 绑定到一个 const StrBlob 对象,因为构造函数接受一个非 const StrBlob 对象的引用

    std::shared_ptr<std::vector<std::string>>
    StrBlobPtr::check(std::size_t i, const std::string &msg) const
    {
    	auto ret = wptr.lock(); // 检查指针指向的`vector`是否还存在
    	if (!ret)
    		throw std::runtime_error("unbound StrBlobPtr");
    	if (i >= ret->size())
    		throw std::out_of_range(msg);
    	return ret; // 否则,返回指向 vector 的 shared_ptr
    }
    
    std::string& StrBlobPtr::deref() const
    {
    	// p 为指向 vector 的 shared_ptr
    	auto p = check(curr, "dereference past end");
    	return (*p)[curr]; // (*p) 是对象所指向的 vector
    }
    
    // 前缀递增:返回递增后的对象的引用
    StrBlobPtr& StrBlobPtr::incr()
    {
    	// 如果curr已经指向容器的尾后位置, 就不能递增它
    	check(curr, "increment past end of StrBlobPtr");
    	++curr; // 推进当前位置
    	return *this;
    }
    
    • 我们还要为StrBlob类定义beginend操作, 返回一个指向它自身的StrBlobPtr:
    // 对于StrBlob中的友元声明来说, 此前置声明是必要的
    class StrBlobPtr;
    class StrBlob {
    	friend class StrBlobPtr;
    	// 其他成员与之前的声明相同
    	// 返回指向首元素和尾后元素的 StrBlobPtr
    	StrBlobPtr begin() { return StrBlobPtr(*this); }
    	StrBlobPtr end()
    		{ 	auto ret = StrBlobPtr(*this, data->size());
    			return ret; }
    };
    

    StrVec

    • 我们将实现标准库vector类的一个简化版本。该类只用于string。因此, 它被命名为StrVec
    • 在本例中,我们不依靠 vector,而是自己进行内存分配

    StrVec 类的设计

    • 我们在StrVec类中使用一个allocator来获得原始内存,将其定义为静态成员,类型为allocator<string>。每个StrVec三个指针成员指向其元素所使用的内存
      • elements, 指向分配的内存中的首元素
      • first_free, 指向最后一个实际元素之后的位置
      • cap, 指向分配的内存末尾之后的位置
        在这里插入图片描述
    • 除此之外, StrVec 还有 4 个工具函数
      • alloc_n_copy分配内存, 并拷贝一个给定范围中的元素
      • free销毁构造的元素并释放内存
      • chk_n_alloc 保证 StrVec 至少有容纳一个新元素的空间。如果没有空间添加新元素, 则调用 reallocate 来分配更多内存
      • reallocate 用来分配新内存

    StrVec 类的定义

    class StrVec {
    public:
    	StrVec(): // allocator 成员进行默认初始化
    		elements(nullptr), first_free(nullptr), cap(nullptr) {}
    	StrVec(std::initializer_list<std::string> il);
    	StrVec(const StrVec&); 
    	StrVec &operator=(const StrVec&); 
    	~StrVec() { free(); }
    	
    	// 接口函数
    	void push_back(const std::string&); 
    	size_t size() const { return first_free - elements; }
    	size_t capacity() const { return cap - elements; }
    	std::string *begin() const { return elements; }
    	std::string *end() const { return first_free; )	
    private:
    	static std::allocator<std::string> alloc; // 用来分配元素
    	// 被添加元素的函数所使用
    	void chk_n_alloc()
    		{ if (size() == capacity()) reallocate(); }
    	// 工具函数, 被拷贝构造函数、赋值运算符和析构函数所使用
    	std::pair<std::string*, std::string*> alloc_n_copy
    		(const std::string*, const std::string*);
    	void free(); 				// 销毁元素并释放内存
    	void reallocate(); 			// 获得更多内存并拷贝已有元素
    	std::string *elements; 		// 指向数组首元素的指针
    	std::string *first_free; 	// 指向数组笫一个空闲元素的指针
    	std::string *cap; 			// 指向数组尾后位置的指针
    };
    
    std::allocator<std::string> StrVec::alloc;	// 定义 static 成员
    
    void StrVec::push_back(const string& s)
    {
    	chk_n_alloc(); // 确保有空间容纳新元素
    	// 使用原始内存,必须先调用 construct 构造对象
    	// 这里使用拷贝构造函数进行初始化
    	alloc.construct(first_free++, s);
    }
    
    // 分配足够的内存来保存给定范围的元素,并将这些元素拷贝到新分配的内存中
    // 返回一个指针的`pair`, 两个指针分别指向新空间的开始位置和拷贝的尾后的位置
    pair<string*, string*>
    StrVec::alloc_n_copy(const string *b, const string *e)
    {
    	// 分配空间保存给定范围中的元素
    	auto data = alloc.allocate(e - b);
    	return {data, uninitialized_copy(b, e, data)};
    }
    
    inline
    StrVec::StrVec(std::initializer_list<std::string> il)
    {
    	auto newdata = alloc_n_data(il.begin(), il.end());
    	elements = newdata.first;
    	first_free = cap = newdata.second;
    }
    
    StrVec::StrVec(const StrVec &s)
    {
    	// 调用 alloc_n_copy 分配空间以容纳与 s 中一样多的元素
    	auto newdata = alloc_n_copy(s.begin(), s.end());
    	elements = newdata.first;
    	first_free = cap = newdata.second;
    }
    
    // 销毁元素 + 释放内存
    void StrVec::free()
    {
    	// 不能传递给 deallocate 一个空指针, 如果 elements 为 0, 函数什么也不做
    	if (elements) {
    		// 逆序销毁旧元素
    		for (auto p = first_free; p != elements; )
    			alloc.destroy(--p);
    		alloc.deallocate(elements, cap - elements);
    	}
    }
    
    • free中的for循环也可以用for_eachlambda表达式来代替:
    for_each(elements, first_free,
    	[](std::string &s) { alloc.destroy(&s); });
    
    StrVec &StrVec::operator=(const StrVec &rhs)
    {
    	// 调用alloc_n_copy分配内存, 大小与rhs中元素占用空间一样多
    	auto data = alloc_n_copy(rhs.begin(), rhs.end());
    	free();
    	elements = data.first;
    	first_free = cap = data.second;
    	return *this;
    }
    

    在重新分配内存的过程中移动而不是拷贝元素:

    • 在编写reallocate成员函数之前, 我们稍微思考一下此函数应该做什么。它应该
      • 为一个新的、更大的string 数组分配内存
      • 在内存空间的前一部分构造对象, 保存现有元素
      • 销毁原内存空间中的元素, 并释放这块内存
    • 观察这个操作步骤,我们可以看出,为一个StrVec重新分配内存空间会引起从旧内存空间到新内存空间逐个拷贝string。当拷贝一个string时, 新string和原string是相互独立的。但是, 如果是reallocate拷贝StrVec中的string, 则一旦将元素从旧空间拷贝到了新空间,我们就会立即销毁原string。因此, 拷贝这些string中的数据是多余的。在重新分配内存空间时, 如果我们能避免分配和释放string的额外开销, StrVec的性能会好得多
    // 每次重新分配内存时都会将 StrVec 的容量加倍
    // 如果 StrVec 为空,我们将分配容纳一个元素的空间
    void StrVec::reallocate()
    {
    	// 我们将分配当前大小两倍的内存空间
    	auto newcapacity = size() ? 2 * size() : 1;
    	// 分配新内存
    	auto newdata = alloc.allocate(newcapacity);
    	// 将数据移动到新内存
    	auto dest = newdata; 		// 指向新数组中下一个空闲位置
    	auto elem = elements; 		// 指向旧数组中下一个元素
    	for (size_t i = 0; i != size(); ++i)
    		alloc.construct(dest++, std::move(*elem++));
    	free(); // 一旦我们移动完元素就释放旧内存空间
    	// 更新我们的数据结构, 执行新元素
    	elements = newdata;
    	first_free = dest;
    	cap = elements + newcapacity;
    }
    
    展开全文
  • linux资源监控nmon

    2011-05-16 15:53:28
    nmon 工具可以帮助在一个屏幕上显示所有...这个高效的工具可以工作于任何屏幕、telnet 会话、甚至拨号线路。另外,它并不会消耗大量的 CPU 周期,通常低于百分之二。在更新的计算机上,其 CPU 使用率将低于百分之一
  • GIT中文资源

    2016-02-05 13:59:59
    1 起步 1 1.1 关于版本控制 . . . . . . . . ....1.1.1 本地版本控制系统 ....1.1.2 集中化的版本控制系统 ....1.1.3 分布式版本控制系统 ....1.2 Git 的历史 ....1.3 Git 基础要点 ....1.3.1 直接快照,而非比较差异 ....
  • 漫谈分组交换网之二

    千次阅读 2021-03-27 11:28:45
    倒退?螺旋上升? 电话网络在持续接近100年的时间一直都是网络的代名词,冷战时期出炉的分布式去中心化分组交换网在30...一切都在重复,云计算和昔日终端登录何异?Google和贝尔何异?就看谁掌握资源了。 在电线是资

    倒退?螺旋上升?

    电话网络在持续接近100年的时间一直都是网络的代名词,冷战时期出炉的分布式去中心化分组交换网在30年后便被一种叫做SDN的理念挑战,这意味着什么?

    谁才是正确的?

    曾经的电话网络是被巨头主宰的,如今的互联网又有同样的趋势,然而互联网不是去中心化的吗?

    互联网先锋们曾经嘲笑电话网就是一个接线的网络,让他们看看现如今的SD-WAN,是不是也是一个接线的网络呢?逻辑的“线”代替了昔日的“铜线”而已。

    一切都在重复,云计算和昔日哑终端登录何异?Google和贝尔何异?就看谁掌握资源了。

    在电线是资源的时代,贝尔(AT&T,北电…)垄断了资本,在数据是资源的时代,Google,Facebook同样也是如此,一帮服务于冷战时期zf军方的学院派整出什么 分布式,去中心化 的网络,迟早会被资本巨头兼并的啊!

    1990年代,一切似乎都按照学院派的思路向前,但是还是出现了雅虎,谷歌,虽然它们并不起眼,至于微软,那是电脑界的,和网络并不相干,但雅虎,谷歌是威胁。

    随着数据逐渐流向这些公司,互联网便不再对称了,不再去中心化了,因为大家都知道,中心就是谷歌的机房,虽然谷歌的机房遍布全世界,对抗核打击是足够了,但现如今的问题已经不是核打击了。

    这个时候,你去跟腾讯云,阿里云,百度…这些公司去谈什么网络去中心化,他们能把你摁到马桶里dis,你去跟一帮天天搞SDN/NFV/TCP加速的人去谈互联网公平性,不要KPI了吗?视角不同,侧重点自然不同。

    电话网络是针对接线的编程,互联网早期是针对端到端的编程,现如今呢?

    范雅各布森在2006年就说过,针对host到host的寻址已经过时了,应该针对data寻址。也是确实,移动互联网在2010年左右到来之后,各种难题印证了范雅各布森观点的正确性。

    然后呢?国内各大有钱没技术的互联网公司的各种行为,是反其道而行之的倒退,还是螺旋上升的低点呢?在我看来,日光之下并无新事,也就坦然吧。


    浙江温州皮鞋湿,下雨进水不会胖。

    展开全文
  • CMutex

    2010-08-04 11:00:17
    CMutex类的对象代表“程(mutex)”——它为一个同步对象,允许某线程共同访问同一资源。在仅仅一个线程被允许用于修改数据或其它被控制的资源时,程将变得非常有用。例如,给链接的列表增添一个结点就是只允许...
  • 资源使用经典hill密码对输入的字符串进行加密和解密,加密矩阵可以根据自己的要求更改,加密过程中3个字母为一组,不足三个时,输出的解密后的字符串用文z补齐。下载解压后,导入MATLAB路径中,直接运行即可。...
  • CMutex中lock应该注意

    千次阅读 2011-06-26 15:58:00
    对于多线程程序中操作共享变量来说,CMutex::Lock()提供了一个不错的办法.CMutex类的对象代表“程(mutex)”——它为一个同步对象,允许某线程共同访问同一资源。在仅仅一个线程被允许用于修改数据或其它被控制的...
  • 【Pandas】【变形】

    2020-07-17 17:38:44
    学习内容与资源来自于Datawhale成员分享,感谢耿同学 Pandas变形1. 透视表1.1 pivot1.2 pivot_table1.2.x 常用参数1.3 crosstab交叉表2. 其他变形方法2.1. melt函数2.2. 压缩与展开3. 变量与因子化3.1. Dummy ...
  • Linux下终端之谈

    2015-12-02 00:19:01
    一台主机,连很多终端,终端为主机提供了人机接口,每个人都通过终端使用主机的资源.。 终端有字符终端和图形终端两种. 个人计算机上只有控制台,没有终端.linux按POSIX标准把个人计算机当成小型机来用,就在控制台...
  • 终端 伪终端 控制终端

    千次阅读 2016-09-27 15:23:58
    首先, 终端 (Terminal)概念通常是指那些与集中式主机系统(例如IBM大型...一台主机,连很多终端,终端为主机提供了人机接口,每个人都通过终端使用主机的资源. 终端有字符终端和图形终端两种.控制台是另一种人机
  • wed应用程序开发原理

    2016-09-20 15:35:00
    ---恢复内容开始--- 企业应用演变的模式 1.主机/终端的集中计算模式 时间二十世纪七十年代,企业应用程序是围绕一个中心大型... 到了八十年代,个人计算机(PC)开始发展开来,这种计算机资源有限,但比终端...
  • 首先,终端 (Terminal)概念通常是指那些与集中式主机系统...一台主机,连很多终端,终端为主机提供了人机接口,每个人都通过终端使用主机的资源. 终端有字符终端和图形终端两种.控制台是另一种人机接口, 不通过终...
  • 一篇文章学会使用 nmon

    千次阅读 2018-06-28 20:22:04
    1.Nmon简介Nmon (Nigel’s Monitor)是由IBM 提供、免费监控 AIX 系统与 Linux 系统资源的工具。该工具可将服务器系统资源耗用情况收集起来并输出一个特定的文件,并可利用 excel ...这个高效的工具可以工作于任何...
  • 一台主机,连很多终端,终端为主机提供了人机接口,每个人都通过终端使用主机的资源. 终端有字符终端和图形终端两种.控制台是另一种人机接口, 不通过终端与主机相连, 而是通过显示卡-显示器和键盘接口分别与主机相连,...
  • Web应用及XHTML基础篇

    2015-07-27 21:16:28
    1、主机/终端模式(Mainframe/Terminal):使用者一般通过只有一个屏幕、一个键盘和一根主机连接线的“终端”与主机的应用程序进行交互。 超市收银航空售票小型储蓄所 2、客户机/服务器(Client/Server):在...
  • Network device support ...这是一个中间层驱动,可以用来灵活的配置资源共享,看不懂的可以不选 Dummy net driver support 接口网络,使用SLIP或PPP传输协议(如ADSL用户)的需要它 Bonding driver support 将多个以
  • 一台主机,连很多终端,终端为主机提供了人机接口,每个人都通过终端使用主机的资源. 终端有字符终端和图形终端两种. 控制台是另一种人机接口, 不通过终端与主机相连, 而是通过显示卡-显示器和键盘接口分别与主机...
  • 主机与终端模式 计算机发展的早期终端是只负责与用户的交互和数据的传送没有处理数据的能力也被称为终端所有的运算和管理功能集中在主机身上特点管理简单方便缺点主机的负担太重终端界面不友好 单机模式 由于硬件...
  • 历史 控制台 终端 计算机内部 计算机外部 并口 串口 ...早期计算机精贵,一台主机,连很多终端,终端为主机提供了人机接口,很多人都通过终端使用主机的资源。终端有字符终端和图形终端...
  • 首先: 1。终端和控制台都不是个人电脑的...一台主机,连很多终端,终端为主机提供了人机接口,每个人都通过终端使用主机的资源. 终端有字符终端和图形终端两种. 控制台是另一种人机接口, 不通过终端与主机相连, 而
  • 一台主机,连很多终端,终端为主机提供了人机接口,每个人都通过终端使用主机的资源. 终端有字符终端和图形终端两种.控制台是另一种人机接口, 不通过终端与主机相连, 而是通过显示卡-显示器和键盘...
  • Network device support

    千次阅读 2018-05-29 19:24:07
    [*] Network device support ---&... Intermediate Functional Block support这是一个中间层驱动,可以用来灵活的配置资源共享,看不懂的可以不选&lt; &gt; Dummy net driver support接口网络,使用S...
  • Unix终端的概念

    千次阅读 2015-11-30 10:52:10
    ...终端和控制台都不是个人...一台主机,连很多终端,终端为主机提供了人机接口,每个人都通过终端使用主机的资源. 终端有字符终端和图形终端两种. 控制台是另一种人机接口, 不通过终端与主机相连, 而是通过显
  • nmon开源性能监控工具,用于监控linux系统的资源消耗信息,并能把结果输出到文件中,然后通过nmon_analyser工具产生数据文件与图形化结果。帮助在一个屏幕上显示所有重要的性能优化信息,并动态地对其进行更新。 ...

空空如也

空空如也

1 2 3 4
收藏数 72
精华内容 28
关键字:

哑资源