@ เก็บรักษามอบหมายสำเนา nonatomic ใน Objective-C

ในฐานะที่เป็นคนใหม่สำหรับ Objective-C ใครบางคนสามารถให้ภาพรวมของการเก็บรักษามอบหมายคัดลอกและอื่น ๆ ที่ฉันหายไปซึ่งเป็นไปตามคำสั่ง @property หรือไม่ พวกเขากำลังทำอะไรและทำไมฉันจึงต้องการใช้งานมากกว่ากัน

บทความที่เชื่อมโยงกับ MrMage ไม่ทำงานอีกต่อไป ดังนั้นนี่คือสิ่งที่ฉันเรียนรู้จากการเขียนโค้ดในระยะเวลาอันสั้นใน Objective-C

nonatomic vs. atomic - "atomic" เป็นค่าเริ่มต้น ใช้ "nonatomic" เสมอ ฉันไม่รู้ว่าทำไม แต่หนังสือที่ฉันอ่านบอกว่ามี "เหตุผลไม่มาก" ที่จะใช้ "อะตอมมิก" (BTW: หนังสือที่ฉันอ่านคือหนังสือ BNR "iOS Programming")

readwrite vs. readonly - "readwrite" เป็นค่าเริ่มต้น เมื่อคุณ @synthesize ทั้ง getter และ setter จะถูกสร้างขึ้นสำหรับคุณ หากคุณใช้ "อ่านอย่างเดียว" จะไม่มีการสร้างตัวตั้งค่า ใช้สำหรับค่าที่คุณไม่ต้องการเปลี่ยนแปลงหลังจากการสร้างอินสแตนซ์ของวัตถุ

รักษาเทียบกับสำเนาและมอบหมาย

• "assign" เป็นค่าเริ่มต้น ใน setter ที่สร้างขึ้นโดย @synthesize ค่าจะถูกกำหนดให้กับแอตทริบิวต์เท่านั้น ความเข้าใจของฉันคือว่า "กำหนด" ควรใช้สำหรับแอตทริบิวต์ที่ไม่ใช่ตัวชี้
• "เก็บ" เป็นสิ่งจำเป็นเมื่อแอตทริบิวต์เป็นตัวชี้ไปยังวัตถุ ตัวตั้งค่าที่สร้างโดย @synthesize จะเก็บรักษา (หรือที่เรียกว่าเพิ่มจำนวนการเก็บรักษา) วัตถุ คุณจะต้องปล่อยวัตถุเมื่อเสร็จแล้ว
• จำเป็นต้องใช้ "การคัดลอก" เมื่อวัตถุไม่แน่นอน ใช้สิ่งนี้หากคุณต้องการคุณค่าของวัตถุอย่างที่เป็นอยู่ในขณะนี้และคุณไม่ต้องการให้ค่านั้นสะท้อนการเปลี่ยนแปลงใด ๆ ที่เกิดขึ้นโดยเจ้าของวัตถุคนอื่น ๆ คุณจะต้องปล่อยวัตถุเมื่อเสร็จแล้วเพราะคุณยังคงรักษาสำเนา

ก่อนที่คุณจะรู้เกี่ยวกับคุณลักษณะของ @property คุณควรทราบว่าการใช้ @property คืออะไร

• @propertyเสนอวิธีการกำหนดข้อมูลที่คลาสมีจุดประสงค์เพื่อแค็ปซูล หากคุณประกาศอ็อบเจ็กต์ / ตัวแปรโดยใช้@propertyดังนั้นอ็อบเจ็กต์ / ตัวแปรนั้นจะสามารถเข้าถึงได้โดยคลาสอื่นที่อิมพอร์ตคลาส

• หากคุณประกาศวัตถุโดยใช้@propertyในไฟล์ส่วนหัวคุณต้องทำการสังเคราะห์โดยใช้@synthesizeในไฟล์การนำไปใช้งาน นี้จะทำให้วัตถุKVC สอดคล้อง โดยค่าเริ่มต้นคอมไพเลอร์จะสังเคราะห์วิธีการเข้าถึงสำหรับวัตถุนี้

• วิธีการเข้าถึงคือ: setter และ getter

ตัวอย่าง: .h

@interface XYZClass : NSObject
@property (nonatomic, retain) NSString *name;
@end

.m

@implementation XYZClass
@synthesize name;
@end

ตอนนี้คอมไพเลอร์จะสังเคราะห์วิธีการเข้าถึงสำหรับชื่อ

XYZClass *obj=[[XYZClass alloc]init];
NSString *name1=[obj name]; // get 'name'
[obj setName:@"liza"]; // first letter of 'name' becomes capital in setter method

• รายการแอตทริบิวต์ของ@property

  ปรมาณู, ไม่ใช่เชิงอะตอม, เก็บ, คัดลอก, อ่านได้อย่างเดียว, readwrite, มอบหมาย, strong, getter = method, setter = method, unsafe_unretained

• atomicเป็นพฤติกรรมเริ่มต้น ถ้าวัตถุถูกประกาศเป็นอะตอมมิกมันจะกลายเป็นเธรดที่ปลอดภัย เธรดที่ปลอดภัยหมายถึงในแต่ละครั้งมีเพียงหนึ่งเธรดของอินสแตนซ์เฉพาะของคลาสนั้นเท่านั้นที่สามารถควบคุมวัตถุนั้นได้

หากเธรดกำลังดำเนินการเมธอด getter ดังนั้นเธรดอื่นไม่สามารถดำเนินการเมธอด setter บนวัตถุนั้น มันช้า

@property NSString *name; //by default atomic`
@property (atomic)NSString *name; // explicitly declared atomic`

• nonatomic ไม่ปลอดภัยต่อเธรด คุณสามารถใช้แอททริบิวคุณสมบัติ nonatomic เพื่อระบุว่าตัวสังเคราะห์ที่เข้าถึงได้ง่ายเพียงแค่ตั้งค่าหรือคืนค่าโดยตรงโดยไม่รับประกันว่าจะเกิดอะไรขึ้นถ้าค่าเดียวกันนั้นถูกเข้าถึงพร้อมกันจากหลาย ๆ เธรด

ด้วยเหตุนี้จึงเร็วกว่าในการเข้าถึงคุณสมบัติที่ไม่ใช่เชิงอะตอมมากกว่าอะตอมมิก

@property (nonatomic)NSString *name;   

• การเก็บรักษาจำเป็นต้องมีเมื่อแอตทริบิวต์เป็นตัวชี้ไปยังวัตถุ

เมธอด setter จะเพิ่มจำนวนการเก็บรักษาออบเจ็กต์เพื่อที่จะได้ครอบครองหน่วยความจำในพูลอัตโนมัติ

@property (retain)NSString *name;

• คัดลอกหากคุณใช้การคัดลอกคุณจะไม่สามารถใช้การเก็บรักษา การใช้อินสแตนซ์คัดลอกของคลาสจะมีสำเนาของตัวเอง

แม้ว่าจะมีการตั้งค่าสตริงที่ไม่แน่นอนและเปลี่ยนแปลงในภายหลังอินสแตนซ์จะเก็บค่าใด ๆ ที่มีอยู่ในเวลาที่ตั้งค่าไว้ ไม่มีการสังเคราะห์ setter และ getter

@property (copy) NSString *name;

ตอนนี้

NSMutableString *nameString = [NSMutableString stringWithString:@"Liza"];    
xyzObj.name = nameString;    
[nameString appendString:@"Pizza"]; 

ชื่อจะไม่ได้รับผลกระทบ

• แบบอ่านอย่างเดียวหากคุณไม่ต้องการให้คุณสมบัติเปลี่ยนผ่านวิธีตัวตั้งค่าคุณสามารถประกาศคุณสมบัติแบบอ่านอย่างเดียว

คอมไพเลอร์จะสร้าง getter แต่ไม่ใช่ setter

@property (readonly) NSString *name;

• readwriteเป็นพฤติกรรมเริ่มต้น คุณไม่จำเป็นต้องระบุแอตทริบิวต์ readwrite อย่างชัดเจน

มันตรงกันข้ามกับอ่านอย่างเดียว

@property (readwrite) NSString *name;

• มอบหมายจะสร้าง setter ซึ่งกำหนดค่าให้กับตัวแปรอินสแตนซ์โดยตรงแทนที่จะคัดลอกหรือเก็บรักษาไว้ สิ่งนี้เหมาะสำหรับประเภทดั้งเดิมเช่น NSInteger และ CGFloat หรือวัตถุที่คุณไม่ได้เป็นเจ้าของโดยตรงเช่นผู้ได้รับมอบหมาย

โปรดทราบว่าการจดจำและการมอบหมายนั้นสามารถใช้แทนกันได้โดยทั่วไปเมื่อเปิดใช้งานการรวบรวมขยะ

@property (assign) NSInteger year;

• strongแทนการเก็บ

มันมาพร้อมกับ ARC

@property (nonatomic, strong) AVPlayer *player; 

• getter = methodหากคุณต้องการใช้ชื่ออื่นสำหรับวิธี getter เป็นไปได้ที่จะระบุชื่อที่กำหนดเองโดยการเพิ่มคุณสมบัติให้กับคุณสมบัติ

ในกรณีของคุณสมบัติบูลีน (คุณสมบัติที่มีค่า YES หรือ NO) มันเป็นธรรมเนียมสำหรับวิธีการ getter ที่จะเริ่มต้นด้วยคำว่า "is"

@property (getter=isFinished) BOOL finished;

• setter = methodหากคุณต้องการใช้ชื่อที่แตกต่างกันสำหรับวิธี setter เป็นไปได้ที่จะระบุชื่อที่กำหนดเองโดยการเพิ่มคุณสมบัติให้กับคุณสมบัติ

วิธีควรลงท้ายด้วยโคลอน

@property(setter = boolBool:) BOOL finished;

• unsafe_unretainedมีคลาสไม่กี่คลาสใน Cocoa และ Cocoa Touch ที่ยังไม่สนับสนุนการอ้างอิงที่อ่อนแอซึ่งหมายความว่าคุณไม่สามารถประกาศคุณสมบัติที่อ่อนแอหรือตัวแปรท้องถิ่นที่อ่อนแอเพื่อติดตามพวกเขา คลาสเหล่านี้รวมถึง NSTextView, NSFont และ NSColorSpace เป็นต้น ถ้าคุณต้องการใช้การอ้างอิงที่อ่อนแอกับหนึ่งในคลาสเหล่านี้คุณต้องใช้การอ้างอิงที่ไม่ปลอดภัย

การอ้างอิงที่ไม่ปลอดภัยคล้ายกับการอ้างอิงที่อ่อนแอซึ่งไม่ได้ทำให้วัตถุที่เกี่ยวข้องยังมีชีวิตอยู่ แต่จะไม่ถูกตั้งค่าเป็นศูนย์หากวัตถุปลายทางถูกจัดสรรคืน

@property (unsafe_unretained) NSObject *unsafeProperty;

หากคุณต้องการระบุหลายแอตทริบิวต์ให้รวมเป็นรายการที่คั่นด้วยเครื่องหมายจุลภาคเช่นนี้

@property (readonly, getter=isFinished) BOOL finished;

หลังจากอ่านบทความมากมายฉันตัดสินใจรวบรวมข้อมูลคุณลักษณะทั้งหมดเข้าด้วยกัน:

1. อะตอม // ค่าเริ่มต้น
2. nonatomic
3. strong = รักษา // เริ่มต้น
4. weak = unsafe_unretained
5. รักษา
6. กำหนด // เริ่มต้น
7. unsafe_unretained
8. สำเนา
9. อ่านเท่านั้น
10. readwrite // ค่าเริ่มต้น

ด้านล่างนี้เป็นลิงค์ไปยังบทความโดยละเอียดที่คุณสามารถค้นหาแอตทริบิวต์เหล่านี้ได้

ขอบคุณมากสำหรับทุกคนที่ให้คำตอบที่ดีที่สุดที่นี่ !!

คุณสมบัติของตัวแปรหรือตัวดัดแปลงใน iOS

นี่คือคำอธิบายตัวอย่างจากบทความ

1. atomic -Atomic หมายถึงเพียงเธรดเดียวที่เข้าถึงตัวแปร (ชนิดสแตติก) - อะตอมเป็นเธรดที่ปลอดภัย - แต่มันช้าในการทำงาน - อะตอมเป็นพฤติกรรมเริ่มต้น - accessors ในสภาพแวดล้อมที่ไม่ได้เก็บขยะ (เช่นเมื่อใช้การเก็บรักษา / ปล่อย / autorelease) จะใช้ล็อคเพื่อให้แน่ใจว่าด้ายอื่นไม่รบกวนการตั้งค่า / รับที่ถูกต้อง ของค่า - มันไม่ได้เป็นคำหลักจริงๆ

ตัวอย่าง:

@property (retain) NSString *name;

@synthesize name;

2. nonatomic -Nonatomic หมายถึงหลายเธรดเข้าถึงตัวแปร (ชนิดไดนามิก) -Nonatomic เป็นเธรดที่ไม่ปลอดภัย - แต่มันเร็วในประสิทธิภาพ --Natatomic ไม่ใช่พฤติกรรมเริ่มต้นเราจำเป็นต้องเพิ่มคำหลักที่ไม่ใช่เชิงอะตอมในคุณสมบัติของคุณสมบัติ - อาจส่งผลให้เกิดพฤติกรรมที่ไม่คาดคิดเมื่อกระบวนการ (เธรด) ที่แตกต่างกันสองตัวเข้าถึงตัวแปรเดียวกันในเวลาเดียวกัน

ตัวอย่าง:

@property (nonatomic, retain) NSString *name;

@synthesize name;

อธิบาย:

สมมติว่ามีคุณสมบัติสตริงอะตอมมิลที่เรียกว่า "ชื่อ" และถ้าคุณเรียก [self setName: @ "A"] จากเธรด A ให้โทร [self setName: @ "B"] จากเธรด B และเรียกใช้ [ชื่อตัวเอง] จาก เธรด C จากนั้นการดำเนินการทั้งหมดในเธรดที่แตกต่างกันจะดำเนินการตามลำดับซึ่งหมายความว่าหากเธรดหนึ่งตัวกำลังดำเนินการ setter หรือ getter เธรดอื่นจะรอ สิ่งนี้ทำให้คุณสมบัติ "ชื่อ" อ่าน / เขียนปลอดภัย แต่ถ้าเธรด D อื่นโทร [ปล่อยชื่อ] พร้อมกันการดำเนินการนี้อาจทำให้เกิดความผิดพลาดเนื่องจากไม่มีการเรียก setter / getter ที่เกี่ยวข้อง ซึ่งหมายความว่าวัตถุนั้นปลอดภัยในการอ่าน / เขียน (ATOMIC) แต่ไม่ปลอดภัยกับเธรดเนื่องจากเธรดอื่นสามารถส่งข้อความประเภทใดก็ได้ไปยังวัตถุพร้อมกัน นักพัฒนาควรตรวจสอบความปลอดภัยของเธรดสำหรับวัตถุดังกล่าว

หากคุณสมบัติ "ชื่อ" ไม่ใช่คุณสมบัติดังนั้นเธรดทั้งหมดในตัวอย่างด้านบน - A, B, C และ D จะดำเนินการพร้อมกันเพื่อสร้างผลลัพธ์ที่คาดเดาไม่ได้ ในกรณีของอะตอมตัวใดตัวหนึ่ง A, B หรือ C จะทำงานก่อน แต่ D ยังคงสามารถทำงานแบบขนานได้

3. strong (iOS4 = รักษา) - มันบอกว่า "เก็บไว้ในกองจนกว่าฉันจะไม่ชี้ไปที่อีกต่อไป" - ในคำอื่น ๆ "ฉันเป็นเจ้าของคุณไม่สามารถ dealloc นี้ก่อนที่จะปรับได้เช่นเดียวกับการเก็บรักษา" - คุณใช้ความแข็งแกร่งเฉพาะในกรณีที่คุณต้องการเก็บรักษาวัตถุ - โดยค่าเริ่มต้นตัวแปรอินสแตนซ์ทั้งหมดและตัวแปรท้องถิ่นเป็นตัวชี้ที่แข็งแกร่ง - โดยทั่วไปเราใช้ความแข็งแกร่งสำหรับ UIViewControllers (รายการผู้ปกครองของรายการ UI) - ใช้งานกับ ARC อย่างหนักและโดยพื้นฐานแล้วจะช่วยให้คุณโดยไม่ต้องกังวลเกี่ยวกับจำนวนการเก็บรักษาของวัตถุ ARC จะปล่อยให้คุณโดยอัตโนมัติเมื่อคุณใช้งานเสร็จการใช้คีย์เวิร์ด strong หมายความว่าคุณเป็นเจ้าของวัตถุ

ตัวอย่าง:

@property (strong, nonatomic) ViewController *viewController;

@synthesize viewController;

4. อ่อนแอ (iOS4 = unsafe_unretained) - กล่าวว่า "เก็บไว้ตราบเท่าที่มีคนอื่นชี้ไปที่มันอย่างยิ่ง" - เช่นเดียวกับการมอบหมายไม่มีการเก็บรักษาหรือการเปิดตัว - การอ้างอิง "อ่อนแอ" เป็นการอ้างอิงที่คุณไม่ได้เก็บไว้ - โดยทั่วไปเราใช้จุดอ่อนสำหรับ IBOutlets (Child's UIViewController) ซึ่งทำงานได้เนื่องจากวัตถุลูกจะต้องมีอยู่ตราบเท่าที่วัตถุแม่ทำ - การอ้างอิงที่อ่อนแอคือการอ้างอิงที่ไม่ได้ป้องกันวัตถุที่อ้างอิงจากการรวบรวมโดยตัวรวบรวมขยะ - อ่อนแอเป็นหลักกำหนดคุณสมบัติที่ไม่ได้รับ ยกเว้นเมื่อวัตถุถูกจัดสรรคืนตัวชี้ที่อ่อนแอจะถูกตั้งค่าเป็นศูนย์โดยอัตโนมัติ

ตัวอย่าง:

@property (weak, nonatomic) IBOutlet UIButton *myButton;

@synthesize myButton;

คำอธิบายที่แข็งแกร่งและอ่อนแอขอขอบคุณ BJ Homer :

ลองนึกภาพวัตถุของเราคือสุนัขและสุนัขต้องการที่จะวิ่งหนี (ถูกจัดสรรคืน) พอยน์เตอร์ที่แข็งแกร่งเป็นเหมือนสายจูงสุนัข ตราบใดที่คุณมีสายจูงสุนัขไว้สุนัขก็จะไม่วิ่งหนี ถ้าคนห้าคนผูกติดกับสุนัขตัวหนึ่ง (ห้าพอยน์เตอร์ชี้ไปที่วัตถุหนึ่ง) จากนั้นสุนัขจะไม่วิ่งหนีจนกว่าจะปลดสายจูงทั้งห้าออก ตัวชี้ที่อ่อนแอในทางกลับกันก็เหมือนเด็กตัวเล็ก ๆ ชี้ไปที่สุนัขและพูดว่า "Look! A dog!" ตราบใดที่สุนัขยังอยู่ในสายจูงเด็กตัวเล็ก ๆ ยังสามารถเห็นสุนัขได้และพวกเขาจะยังคงชี้ไปที่มัน แต่ทันทีที่สายจูงทั้งหมดหลุดออกมาสุนัขจะวิ่งหนีไปไม่ว่าเด็กเล็ก ๆ จำนวนหนึ่งจะชี้ไปยังมัน ทันทีที่ตัวชี้ที่รัดกุม (leash) ไม่ชี้ไปที่วัตถุอีกต่อไปวัตถุจะถูกยกเลิกการจัดสรรและตัวชี้ที่อ่อนแอทั้งหมดจะถูกทำให้เป็นศูนย์ เมื่อเราใช้อ่อน ครั้งเดียวที่คุณต้องการใช้ความอ่อนแอคือถ้าคุณต้องการหลีกเลี่ยงการเก็บรอบ (เช่นผู้ปกครองรักษาเด็กและเด็กยังคงผู้ปกครองดังนั้นจึงไม่เคยปล่อย)

5. รักษา = strong - มันถูกเก็บไว้ค่าเก่าจะถูกปล่อยออกมาและมันได้รับมอบหมาย --retain ระบุค่าใหม่ควรจะส่ง - ได้รับในการมอบหมายและค่าเก่าที่ส่ง - ปล่อย - -retain เป็นเช่นเดียวกับที่แข็งแกร่ง -apple บอกว่าถ้าคุณเขียนเก็บมันจะแปลงโดยอัตโนมัติ / ทำงานอย่างแข็งแกร่งเท่านั้น - วิธีเช่น "alloc" รวมถึง "เก็บ" โดยปริยาย

ตัวอย่าง:

@property (nonatomic, retain) NSString *name;

@synthesize name;

6. กำหนด -assign เป็นค่าเริ่มต้นและทำการกำหนดตัวแปรเพียงอย่างเดียว - Assign เป็นคุณสมบัติของคุณสมบัติที่บอกคอมไพเลอร์ว่าจะสังเคราะห์การประยุกต์ใช้ setter ของคุณสมบัติอย่างไรฉันจะใช้ assign สำหรับคุณสมบัติดั้งเดิมของ C และอ่อนแอสำหรับการอ้างอิงวัตถุ Object-C อ่อน

ตัวอย่าง:

@property (nonatomic, assign) NSString *address;

@synthesize address;

7. unsafe_unretained

   -unsafe_unretained เป็นตัวระบุความเป็นเจ้าของที่บอก ARC ถึงวิธีการแทรกการโทรออก / พักสาย -unsafe_unretained เป็นเวอร์ชั่น ARC ของการมอบหมาย

ตัวอย่าง:

@property (nonatomic, unsafe_unretained) NSString *nickName;

@synthesize nickName;

8. สำเนา ถูกต้องเมื่อวัตถุที่ไม่แน่นอน - สำเนาระบุค่าใหม่ที่ควรจะส่ง - คัดลอกในการกำหนดและค่าเก่าส่ง - ปล่อย - คัดลอกเป็นเหมือนเก็บส่งคืนวัตถุที่คุณต้องปล่อยอย่างชัดเจน (เช่นใน dealloc) ในสภาพแวดล้อมที่ไม่ได้เก็บรวบรวมขยะ หากคุณใช้การคัดลอกแล้วคุณยังต้องปล่อยใน dealloc - ใช้สิ่งนี้หากคุณต้องการคุณค่าของวัตถุในขณะนี้และคุณไม่ต้องการให้ค่านั้นสะท้อนการเปลี่ยนแปลงใด ๆ ที่เกิดขึ้นโดยเจ้าของวัตถุคนอื่น ๆ คุณจะต้องปล่อยวัตถุเมื่อเสร็จแล้วเพราะคุณยังคงรักษาสำเนา

ตัวอย่าง:

@property (nonatomic, copy) NSArray *myArray;

@synthesize myArray;

คุณสมบัติอะตอมสามารถเข้าถึงได้ครั้งละหนึ่งเธรดเท่านั้น มันคือความปลอดภัยด้าย ค่าเริ่มต้นคืออะตอมโปรดทราบว่าไม่มีคำหลัก อะตอมมิก

Nonatomicหมายถึงหลายเธรดสามารถเข้าถึงรายการเป็นเธรดที่ไม่ปลอดภัย

ดังนั้นควรระมัดระวังเป็นอย่างยิ่งขณะใช้งานอะตอมมิกมันส่งผลต่อประสิทธิภาพของรหัสของคุณ

ต้องการลิงก์นี้เกี่ยวกับคุณสมบัติใน Object-c ใน iOS ...

https://techguy1996.blogspot.com/2020/02/properties-in-objective-c-ios.html