কোডটি কিছুটা দিয়ে শুরু করা যাক:
class A
{
using MutexType = std::mutex;
using ReadLock = std::unique_lock<MutexType>;
using WriteLock = std::unique_lock<MutexType>;
mutable MutexType mut_;
std::string field1_;
std::string field2_;
public:
...
আমি সেখানে কিছু পরিবর্তে পরামর্শমূলক ধরণের এলিয়াস রেখেছি যে আমরা সত্যই সি ++ 11 তে সুবিধা নেব না, তবে সি ++ 14 এ আরও দরকারী হয়ে উঠব। ধৈর্য ধরুন, আমরা সেখানে পৌঁছে যাব।
আপনার প্রশ্নটি এখানে ফোটে:
এই ক্লাসের জন্য আমি কীভাবে মুভ কনস্ট্রাক্টর এবং মুভ এসাইনমেন্ট অপারেটর লিখব?
আমরা মুভ কনস্ট্রাক্টর দিয়ে শুরু করব।
কনস্ট্রাক্টর সরান
নোট করুন যে সদস্যটি mutexকরা হয়েছে mutable। সরানো সদস্যদের জন্য কড়া কথা বলতে এটি প্রয়োজনীয় নয়, তবে আমি ধরে নিচ্ছি আপনিও অনুলিপি সদস্যদের চান want যদি এটি না হয় তবে মিউটেক্স তৈরি করার দরকার নেই mutable।
নির্মাণের সময় A, আপনাকে লক করার দরকার নেই this->mut_। তবে আপনি যে mut_পদক্ষেপটি তৈরি করছেন তা লক করা দরকার (সরানো বা অনুলিপি)। এটি এর মতো করা যেতে পারে:
A(A&& a)
{
WriteLock rhs_lk(a.mut_);
field1_ = std::move(a.field1_);
field2_ = std::move(a.field2_);
}
নোট করুন যে আমাদের thisপ্রথমে সদস্যদের ডিফল্টরূপে নির্মাণ করতে হয়েছিল এবং তারপরে a.mut_লক হওয়ার পরে কেবল তাদের মান নির্ধারণ করতে হয়েছিল ।
বরাদ্দকরণ
মুভ অ্যাসাইনমেন্ট অপারেটর যথেষ্ট পরিমাণে জটিল কারণ আপনি জানেন না যে অন্য কোনও থ্রেড অ্যাসাইনমেন্ট এক্সপ্রেশনটির lhs বা rh হয় অ্যাক্সেস করছে কিনা। এবং সাধারণভাবে, আপনাকে নিম্নলিখিত পরিস্থিতিতে রক্ষা করতে হবে:
x = std::move(y);
y = std::move(x);
এখানে মুভ অ্যাসাইনমেন্ট অপারেটর যা উপরের দৃশ্যকে সঠিকভাবে রক্ষা করে:
A& operator=(A&& a)
{
if (this != &a)
{
WriteLock lhs_lk(mut_, std::defer_lock);
WriteLock rhs_lk(a.mut_, std::defer_lock);
std::lock(lhs_lk, rhs_lk);
field1_ = std::move(a.field1_);
field2_ = std::move(a.field2_);
}
return *this;
}
নোট করুন যে একটিকে অবশ্যই std::lock(m1, m2)একের পর এক লক করার পরিবর্তে দুটি মুটেক্সকে লক করতে ব্যবহার করতে হবে । আপনি যদি একে একে একে একে লক করে রাখেন, তারপরে যখন দুটি থ্রেড দুটি উপরে উল্লিখিত হিসাবে দুটি বিপরীতে ক্রম স্থির করে, আপনি একটি অচলাবস্থা পেতে পারেন। বিন্দুstd::lock হ'ল সেই অচলাবস্থা এড়ানো।
অনুলিপি নির্মাণকারী
আপনি অনুলিপি সদস্যদের সম্পর্কে জিজ্ঞাসা করেননি, তবে আমরা এখনই তাদের সম্পর্কে ভালভাবে কথা বলতে পারি (যদি আপনি না হন তবে কারওর প্রয়োজন হবে)।
A(const A& a)
{
ReadLock rhs_lk(a.mut_);
field1_ = a.field1_;
field2_ = a.field2_;
}
অনুলিপি কনস্ট্রাক্টরটিকে অনেকটা মুভ কনস্ট্রাক্টরের মতো দেখতে ReadLockপাওয়া যায় পরিবর্তে এর পরিবর্তে ওরফে ব্যবহার করা হয় WriteLock। বর্তমানে এই দুটি ওরফেstd::unique_lock<std::mutex> এবং তাই এটি সত্যিকার অর্থে কোনও পার্থক্য করে না।
তবে সি ++ এ, আপনার এই কথাটি বলার বিকল্প থাকবে:
using MutexType = std::shared_timed_mutex;
using ReadLock = std::shared_lock<MutexType>;
using WriteLock = std::unique_lock<MutexType>;
এটি একটি অপ্টিমাইজেশন হতে পারে, তবে অবশ্যই না। এটি কিনা তা নির্ধারণ করতে আপনাকে পরিমাপ করতে হবে। তবে এই পরিবর্তনের সাথে সাথে একসাথে একাধিক থ্রেডে একই আরএইচএস থেকে কন্ট্রাক্ট অনুলিপি করা যায় । সি ++ 11 সমাধান আপনাকে এই ধরনের থ্রেডগুলিকে অনুক্রমিক করে তুলতে বাধ্য করে, যদিও আরএইচএস পরিবর্তন করা হচ্ছে না।
অ্যাসাইনমেন্ট কপি করুন
সম্পূর্ণতার জন্য, এখানে অনুলিপি অ্যাসাইনমেন্ট অপারেটর, যা অন্য সমস্ত কিছু পড়ার পরে মোটামুটি স্ব-বর্ণনামূলক হওয়া উচিত:
A& operator=(const A& a)
{
if (this != &a)
{
WriteLock lhs_lk(mut_, std::defer_lock);
ReadLock rhs_lk(a.mut_, std::defer_lock);
std::lock(lhs_lk, rhs_lk);
field1_ = a.field1_;
field2_ = a.field2_;
}
return *this;
}
এবং ইত্যাদি.
Aযদি আপনি একাধিক থ্রেডগুলি একবারে কল করতে সক্ষম হন বলে আশা করেন তবে অন্য যে কোনও সদস্য বা ফ্রি ফাংশনগুলির রাজ্যে অ্যাক্সেস রয়েছে সেগুলিও সুরক্ষিত হওয়া দরকার। উদাহরণস্বরূপ, এখানে swap:
friend void swap(A& x, A& y)
{
if (&x != &y)
{
WriteLock lhs_lk(x.mut_, std::defer_lock);
WriteLock rhs_lk(y.mut_, std::defer_lock);
std::lock(lhs_lk, rhs_lk);
using std::swap;
swap(x.field1_, y.field1_);
swap(x.field2_, y.field2_);
}
}
মনে রাখবেন যে আপনি যদি কেবল std::swapকাজটি করার উপর নির্ভর করেন তবে লকিংটি ভুল দানাদারতায় থাকবে, std::swapঅভ্যন্তরীণভাবে সঞ্চালিত তিনটি চালকের মধ্যে লকিং এবং আনলক হবে।
প্রকৃতপক্ষে, চিন্তাভাবনা swapআপনাকে এপিআই সম্পর্কে অন্তর্দৃষ্টি দিতে পারে আপনার "থ্রেড-সেফ" সরবরাহের প্রয়োজন হতে পারে Aযা সাধারণত "লকিং গ্রানুলারিটি" ইস্যুর কারণে "নন-থ্রেড-সেফ" এপিআই থেকে আলাদা হবে।
"স্ব-অদলবদল" থেকে রক্ষা করার প্রয়োজনীয়তাটিও নোট করুন। "স্ব-অদলবদল" এর কোনও অপশন হওয়া উচিত। স্বতঃপরীক্ষা ব্যতীত পুনরাবৃত্তভাবে একই মিটেক্সটিকে লক করা হবে। এই ব্যবহার করে স্ব-চেক ছাড়া সমাধান করা যেতে পারে std::recursive_mutexজন্যMutexType ।
হালনাগাদ
ইয়াক্ক নীচের মন্তব্যে অনুলিপিটি কপির এবং মুভ কনস্ট্রাক্টরগুলিতে ডিফল্ট নির্মাণের বিষয়ে অসন্তুষ্ট (এবং তার একটি বক্তব্য রয়েছে)। আপনি যদি এই সমস্যাটি সম্পর্কে দৃ strongly়ভাবে অনুভব করেন, যাতে আপনি এটির উপর মেমরি ব্যয় করতে ইচ্ছুক হন, আপনি এটিকে এড়াতে পারেন:
ডেটা সদস্য হিসাবে আপনার প্রয়োজন মতো লক টাইপ যুক্ত করুন। এই সদস্যদের অবশ্যই সুরক্ষিত থাকা ডেটার আগে আসতে হবে:
mutable MutexType mut_;
ReadLock read_lock_;
WriteLock write_lock_;
এবং তারপরে কনস্ট্রাক্টরগুলিতে (যেমন অনুলিপি নির্মাণকারী) এটি করুন:
A(const A& a)
: read_lock_(a.mut_)
, field1_(a.field1_)
, field2_(a.field2_)
{
read_lock_.unlock();
}
ওফস, ইয়াক্ক আমার এই আপডেটটি সম্পূর্ণ করার সুযোগ পাওয়ার আগে তার মন্তব্য মুছে ফেলল। তবে এই ইস্যুটি চাপ দেওয়ার এবং এই উত্তরের সমাধান পাওয়ার জন্য তিনি creditণ পাওয়ার যোগ্য।
আপডেট 2
এবং ডাইপ এই ভাল পরামর্শ নিয়ে আসে:
A(const A& a)
: A(a, ReadLock(a.mut_))
{}
private:
A(const A& a, ReadLock rhs_lk)
: field1_(a.field1_)
, field2_(a.field2_)
{}