海口建设公司网站,电商网页设计公司,室内设计师网站有哪些,河南网站建设公司设计模式需要用到面向对象的三大特性——封装、继承、多态#xff08;同名函数具有不同的状态#xff09; UML类图 eg.—— 描述类之间的关系#xff08;设计程序之间画类图#xff09; : public; #: protected; -: private; 下划线: static
属性名:类型#xff08;默认值…设计模式需要用到面向对象的三大特性——封装、继承、多态同名函数具有不同的状态 UML类图 eg.—— 描述类之间的关系设计程序之间画类图 : public; #: protected; -: private; 下划线: static
属性名:类型默认值
方法和变量分开-------
虚函数斜体纯虚函数在虚函数类型后0并且类名斜体 类与类之间的关系
1. 继承关系空心三角形实线箭头指父类
2. 关联关系单项关联、双向关联、自关联 - 链表用带箭头和不带箭头的实现
3. 聚合关系整体与部分的关系整体析构部分不析构空心菱形实线链接指向整体
4. 组合关系整体析构部分析构实心菱形实线链接
5. 依赖关系使用关系带箭头的虚线指向被依赖方
类之间的关系强弱继承泛化组合聚合关联依赖类图按类间最强关系就可 设计模式三原则
单一职责原则面向对象
使得类的功能尽量单一方便管理维护避免类的臃肿。
开放封闭原则
对于扩展是开放的对于修改是封闭的增加程序可维护性可扩展性。
依赖转换原则
高层模块不应该依赖低层模块应用程序不直接调用API两个都应该依赖抽象。
抽象不依赖细节细节应该依赖抽象。里氏代换原则 单例模式和任务队列类的对象只能创建出一个
一个项目中全局范围内某个类的实例有且仅有一个通过这个实例向其他模块提供数据的全局访问。简介访问实现对于变量的保护
将类的默认构造函数和拷贝构造函数设为private或者将两个函数delete
使类无法在外面创建对象只能通过类名访问静态属性或者方法 懒汉模式和饿汉模式
饿汉模式——定义类的时候创建单例对象(多线程下没有线程安全问题)
// 饿汉模式
#include bits/stdc.h
using namespace std;class A{
public:A(const A a) delete;A operator (const A a) delete;static A* get(){return num;}print(){cout单例模式的唯一实例;}
private:A() default; // 默认构造 static A* num;
};A* A::num new A;int main(){A* a A::get();a-print(); return 0;
}
懒汉模式——什么时候使用单例对象再去创建实例多线程下存在线程安全问题
// 懒汉模式
#include bits/stdc.h
using namespace std;class A{
public:A(const A a) delete;A operator (const A a) delete;static A* get(){num new A;return num;}print(){cout单例模式的唯一实例;}
private:A() default; // 默认构造 static A* num;
};A* A::num nullptr;int main(){A* a A::get();a-print(); return 0;
} 懒汉模式的线程安全问题
可以通过双重检查锁定解决懒汉模式的线程安全问题1. 互斥锁导致效率低 2. 实例创建判定
// 懒汉模式
#include bits/stdc.h
using namespace std;class A{
public:A(const A a) delete;A operator (const A a) delete;static A* get(){ // first checkif(numnullptr){lk.lock();if(numnullptr)num new A; // second check lk.unlock();}return num;}print(){cout单例模式的唯一实例;}
private:A() default; // 默认构造 static A* num;static mutex lk;
};A* A::num nullptr;
mutex A::lk;int main(){A* a A::get();a-print(); return 0;
}
通过原子变量atomic - 底层控制机器指令执行顺序解决双重检查锁定的问题放置底层的机器指令不按理想顺序执行
// 懒汉模式
#include bits/stdc.h
using namespace std;class A{
public:A(const A a) delete;A operator (const A a) delete;static A* get(){ // first checkA* cur task.load();if(curnullptr){lk.lock();cur task.load();if(curnullptr){cur new A; // second checktask.store(cur);} lk.unlock();}return cur;}print(){cout单例模式的唯一实例;}
private:A() default; // 默认构造 static A* num;static mutex lk;static atomicA* task;
};A* A::num nullptr;
mutex A::lk;
atomicA* A::task;int main(){A* a A::get();a-print(); return 0;
}
使用静态局部对象解决线程安全问题
#include bits/stdc.h
using namespace std;class A{
public:A(const A a) delete;A operator (const A a) delete;static A* get(){ // first checkstatic A a;return a; }print(){cout单例模式的唯一实例;}
private:A() default; // 默认构造
};int main(){A* a A::get();a-print(); return 0;
}
并发执行应当等待变量完成初始化 总结
1. 饿汉模式不存在线程安全问题
2. 懒汉模式通过双重检查锁定原子变量或者静态局部对象简单可以解决线程安全问题 实践多线程模式下的任务模型
#include bits/stdc.h
using namespace std;// 饿汉模式
#include bits/stdc.h
using namespace std;class A{
public:A(const A a) delete;A operator (const A a) delete;static A* get(){return num;}print(){cout单例模式的唯一实例;}bool isempty(){lock_guardmutex locker(m_mutex);return mis.empty(); }void add_m(int node){lock_guardmutex locker(m_mutex);mis.push(node);}bool minus_m(){lock_guardmutex locker(m_mutex);if(mis.empty())return false;else{mis.pop();}return true;}int get_m(){lock_guardmutex locker(m_mutex);if(mis.empty())return -1;return mis.front(); }
private:A() default; // 默认构造 static A* num;queueint mis;mutex m_mutex;
};A* A::num new A;int main(){A *a A::get();// 生产者thread t1([](){for(int i 0 ; i10 ; i){a-add_m(i100);coutpush data: i100 threadId: this_thread::get_id()endl;this_thread::sleep_for(chrono::milliseconds(500));} });// 消费者 thread t2([](){this_thread::sleep_for(chrono::milliseconds(100));while(!a-isempty()){int cur a-get_m();couttake data: cur threadId: this_thread::get_id()endl;a-minus_m();this_thread::sleep_for(chrono::milliseconds(1000));} });// 阻塞主线程 t1.join();t2.join();return 0;
}
