c# pdf to tiff : Add signature box to pdf Library SDK API .net asp.net html sharepoint Python%20How%20to%20Program%20200262-part1750

Chapter 19
Multithreading
751
© Copyright 1992–2002 by Deitel & Associates, Inc. All Rights Reserved. 8/21/01
run method. Attribute sleepTime stores a random integer value determined when a
PrintThread object is constructed. When started, each PrintThread object sleeps
for the amount of time specified by sleepTime, and then outputs its name. 
The PrintThread constructor (lines 11– – 17) first calls the base class constructor.
passing  the  class  instance  and  the  thread’s  name.  A  thread’s  name  is  specified  with
Thread keyword argument name. If no name is specified, the thread will be assigned a
unique name in the form "Thread-n" where n is an integer. The constructor then initial-
izes sleepTime to a random integer between 1 and 5, inclusive. Then, the program out-
puts the name of the thread and the value of sleepTime, to show the values for the
particular PrintThread being constructed.
When a PrintThread’s start method (inherited from Thread) is invoked, the
PrintThread object enters the ready state. When the interpreter switches in the
PrintThread object, it enters the running state and its run method begins execution.
Method run (lines 20– – 25) prints a message indicating that the thread is going to sleep and
then invokes function time.sleep (line 24) to immediately put the thread into a sleeping
state. When the thread awakens after sleepTime seconds, it is placed into a ready state
again until it is switched into the processor. When the PrintThread object enters the
running state again, it outputs its name (indicating that the thread is done sleeping), its run
method terminates and the thread object enters the dead state.
The main portion of the program instantiates four PrintThread objects and invokes
the Thread class start method on each one to place all four PrintThread objects in
ready state. After this, the main program’s thread terminates. However, the example con-
tinues running until the last PrintThread dies (i.e., has completed its run method). 
19.5 Thread Synchronization
Multithreaded programs often contain code wherein two or more threads attempt to access
and/or modify the value of a shared piece of data. For example, two threads may be reading
and updating the value of a variable simultaneously. If a multithreaded program does not
protect access to the shared variable, the value of that variable may become corrupted. The
sections of code that access shared data are often referred to as critical sections. To prevent
multiple threads from changing data simultaneously, multithreaded programs typically re-
strict how many threads can execute the code in a critical section at a time. This restriction
is accomplished through various synchronization primitives.
The threading module provides many thread synchronization primitives. The most
primitive  synchronization  mechanism  is  the lock.  A  lock  object  (created  with  class
threading.Lock) defines two methods— acquire and release. When a thread
calls the acquire method, the lock enters its locked state. Once a lock has been acquired,
no other threads may acquire the lock until the lock is released. This means that if another
thread calls a lock’s acquire method, the thread will block indefinitely. When the orig-
inal thread calls the lock’s release method, the lock enters the unlocked state and the
blocked thread is notified (awakened). At this point, the previously blocked thread acquires
the lock. If more than one thread is blocked on a lock, only one of those threads is notified.
Locks can be used to restrict access to a critical section. The program is written such
that the thread must acquire a lock before entering a critical section and release the lock
when exiting the critical section. Thus, if one thread is executing the critical section, any
Add signature box to pdf - C# PDF File Permission Library: add, remove, update PDF file permission in C#.net, ASP.NET, MVC, WPF
Tell C# users how to set PDF file permissions, like printing, copying, modifying, extracting, annotating, form filling, etc
click to sign pdf; adding signature to pdf doc
Add signature box to pdf - VB.NET PDF File Permission Library: add, remove, update PDF file permission in vb.net, ASP.NET, MVC, WPF
VB.NET Tutorial for How to Set PDF File Access Permissions Using XDoc.PDF for .NET
pdf create signature; export pdf to word sign in
752
Multithreading
Chapter 19
© Copyright 1992–2002 by Deitel & Associates, Inc. All Rights Reserved. 8/21/01
other thread that attempts to enter the critical section will block until the original thread has
exited the critical section.
Such a procedure provides only the most basic level of synchronization. Sometimes,
however, we would like to create more sophisticated threads that access a critical section
only when some event occurs (i.e., a data value has changed). This can be done by using
condition variables. A thread uses a condition variable when the thread wants to monitor
the state of some object or wants to be notified when some event occurs. When the object’s
state changes or the event occurs, blocked threads are notified. We discuss condition vari-
ables throughout this chapter in the context of the classic producer/consumer problem. The
solution involves a consumer thread that accesses a critical section only when notified by
a producer thread, and vice versa.
Condition variables are created with class threading.Condition. Because con-
dition variables  contain an underlying lock, condition variables provide acquire and
release methods. Additional condition variable methods are wait and notify. When
a thread  has  acquired the underlying lock, calling method wait  releases the lock and
causes the thread to block until it is awakened by a call to notify on the same condition
variable. Calling method notify wakes up one thread waiting on the condition variable.
All waiting threads can be woken up by invoking the condition variable’s notifyAll
method.
Semaphores (created with class threading.Semaphore) are synchronization
primitives that allow a set number of threads to access a critical section. The Semaphore
object uses a counter to keep track of the number of threads that acquire and release the
semaphore. When a thread calls method acquire, the thread blocks if the counter is 0.
Otherwise,  the  thread  acquires  the  semaphore  and  method acquire  decrements  the
counter. Calling method release releases the semaphore, increments the counter and
notifies a waiting thread. The initial value of the internal counter can be passed as an argu-
ment to the Semaphore constructor (default is 1). Because the internal counter can never
have a negative value, specifying a negative counter value raises an AssertionError
exception.
Sometimes, one or more threads want to wait for a particular event to occur before pro-
ceeding with their execution. An Event object (created with class threading.Event)
has an internal flag that is initially set to false (i.e., the event has not occurred). A thread
that calls Event method wait blocks until the  event occurs. When the event occurs,
method set is called to set the flag to true and awaken all waiting threads. A thread that
calls wait after the flag is true does not block at all. Method isSet returns true if the flag
is true. Method clear sets the flag to false.
Writing a program that uses locks, condition variables or any other synchronization
primitive takes careful scrutiny to ensure that the program does not deadlock. A program
or thread deadlocks when the program or thread blocks forever on a needed resource. For
example, consider the scenario where a thread enters a critical section that tries to open a
file. If the file does not exists and the thread does not catch the exception, the thread termi-
nates before releasing the lock. Now all other threads will deadlock, because they block
indefinitely after they call the lock’s acquire method.
Common Programming Error 19.1
Threads in the waiting state for a lock object must eventually be awakened explicitly (i.e., by
releasing the lock) or the thread will wait forever. This may cause deadlock.
19.1
C# PDF Digital Signature Library: add, remove, update PDF digital
Highlight Text. Add Text. Add Text Box. Drawing Markups. OCR. Twain. Edit Digital Signatures. |. Home ›› XDoc.PDF ›› C# PDF: Edit PDF Digital Signature.
add signature to preview pdf; create pdf signature box
C# WinForms Viewer: Load, View, Convert, Annotate and Edit PDF
Add text box to PDF file in preview. • Draw PDF markups. PDF Protection. • Sign PDF document with signature. • Erase PDF text. • Erase PDF images.
add signature pdf; pdf export sign in
Chapter 19
Multithreading
753
© Copyright 1992–2002 by Deitel & Associates, Inc. All Rights Reserved. 8/21/01
Testing and Debugging Tip 19.2
Be sure that every call to acquire has a corresponding call to release that will eventu-
ally end the waiting.
19.2
Performance Tip 19.4
Synchronization to achieve correctness in multithreaded programs can make programs run
slower due to lock overhead and frequently moving threads between the running, waiting and
ready states. There is not much to say, however, for highly efficient, incorrect multithreaded
programs!
19.4
19.6 Producer/Consumer Relationship Without Thread 
Synchronization
In this section, we use a producer/consumer relationship to demonstrate the wait and no-
tify methods of a condition variable. In a producer/consumer relationship, a producer
thread calling a produce method may see that the consumer thread has not read the last
message from a shared region of memory called a buffer, so the producer thread calls wait
on a condition variable. When a consumer thread reads the message, it calls notify on
the condition variable to allow a waiting producer to proceed. When a consumer thread
calls a consume method and finds the buffer empty, it calls wait. A producer calling a pro-
duce method and finding the buffer empty, writes to the buffer, then calls notify so a
waiting consumer can proceed. 
Shared data can get corrupted if we do not synchronize access among multiple threads.
Consider a producer/consumer relationship in which a producer thread deposits a sequence
of numbers (we use 1, 2, 3, … … ) into a slot of shared memory. The consumer thread reads
this data from the shared memory and prints the data. Figure 19.3 demonstrates a producer
(defined in Fig. 19.4) and a consumer (defined in Fig. 19.5) accessing a single shared cell
of memory without any synchronization (defined in Fig. 19.6). The program prints what the
producer produces as it produces it and what the consumer consumes as it consumes it.
1
# Fig. 19.3: fig19_03.py
2
# Show multiple threads modifying shared object.
3
4
from UnsynchronizedInteger import UnsynchronizedInteger
5
from ProduceInteger import ProduceInteger
6
from ConsumeInteger import ConsumeInteger
7
8
# initialize integer and threads
9
number = UnsynchronizedInteger()
10
producer = ProduceInteger( "Producer", number )
11
consumer = ConsumeInteger( "Consumer", number )
12
13
print "Starting threads...\n"
14
15
# start threads
16
producer.start()
17
consumer.start()
Fig. 19.3
Fig. 19.3
Fig. 19.3
Fig. 19.3
Threads modifying unsynchronized shared object (part 1 of 2).
VB.NET PDF Digital Signature Library: add, remove, update PDF
Highlight Text. Add Text. Add Text Box. Drawing Markups. Twain. Edit Digital Signatures. |. Home ›› XDoc.PDF ›› VB.NET PDF: Edit PDF Digital Signature.
add signature pdf online; pdf signature
C# PDF insert image Library: insert images into PDF in C#.net, ASP
How to insert and add image, picture, digital photo, scanned signature or logo into PDF document page in C#.NET class application?
create signature pdf; create pdf stamp signature
754
Multithreading
Chapter 19
© Copyright 1992–2002 by Deitel & Associates, Inc. All Rights Reserved. 8/21/01
Because the threads are not synchronized, data can be lost if the producer places new
data into the slot before the consumer consumes the previous data, and data can be “ “ dou-
bled”  if the consumer consumes data again before the producer produces the next item. To
show these possibilities, the consumer thread in this example sums all the values it reads.
The producer thread produces values from 1 to 10. If the consumer is able to read each
value produced once, the sum would be 55. However, if you execute this program several
times, you will see that the total is rarely, if ever, 55.
Figure 19.3 instantiates  the shared UnsynchronizedInteger  object number
and uses it as the argument to the constructors for the ProduceInteger object pro-
ducer and the ConsumeInteger object consumer. Next, the program invokes the
Thread class start method on objects producer and consumer to place them in the
ready state (lines 16– 17). This statement launches the two threads. Lines 20– 21 call
Thread method join to ensure that the main program waits indefinitely for both threads
18
19
# wait for threads to terminate
20
producer.join()
21
consumer.join()
22
23
print "\nAll threads have terminated."
Starting threads...
Producer setting sharedNumber to 1
Producer setting sharedNumber to 2
Consumer retrieving sharedNumber value 2
Consumer retrieving sharedNumber value 2
Consumer retrieving sharedNumber value 2
Producer setting sharedNumber to 3
Consumer retrieving sharedNumber value 3
Producer setting sharedNumber to 4
Consumer retrieving sharedNumber value 4
Consumer retrieving sharedNumber value 4
Consumer retrieving sharedNumber value 4
Producer setting sharedNumber to 5
Consumer retrieving sharedNumber value 5
Producer setting sharedNumber to 6
Producer setting sharedNumber to 7
Producer setting sharedNumber to 8
Producer setting sharedNumber to 9
Consumer retrieving sharedNumber value 9
Consumer retrieving sharedNumber value 9
Consumer retrieved values totaling: 44
Terminating Consumer
Producer setting sharedNumber to 10
Producer finished producing values
Terminating Producer
All threads have terminated.
Fig. 19.3
Fig. 19.3
Fig. 19.3
Fig. 19.3
Threads modifying unsynchronized shared object (part 2 of 2).
.NET PDF Document Viewing, Annotation, Conversion & Processing
PDF Write. Insert text, text box into PDF. Add, Update, Delete form fields programmatically. Document Protect. Allow to create digital signature.
add signature to pdf acrobat reader; adding a signature to a pdf document
VB.NET PDF insert image library: insert images into PDF in vb.net
project. Import graphic picture, digital photo, signature and logo into PDF document. Add images to any selected PDF page in VB.NET.
pdf signature field; add signature to pdf preview
Chapter 19
Multithreading
755
© Copyright 1992–2002 by Deitel & Associates, Inc. All Rights Reserved. 8/21/01
to terminate before continuing. Notice that line 23 is executed after both threads have ter-
minated.
Class ProduceInteger— — a  subclass  of threading.Thread— — consists  of
attribute sharedObject, a constructor (lines 11– – 15) and a run method (lines 17– – 25).
The constructor initializes attribute sharedObject to refer to the Unsynchronized-
Integer object passed as an argument. 
Class ProduceInteger’s run method consists of a for structure that loops ten
times. Each iteration of the loop first invokes function time.sleep to put the Produ-
ceInteger object into the sleeping state for a random time interval between 0 and 3 sec-
onds. When  the  thread awakens,  it  invokes  the shared  object’s setSharedNumber
method (line 22) with the value of control variable i to set the shared object’s data member.
When the loop completes, the ProduceInteger thread displays a line in the command
window indicating that it has finished producing data and terminates (i.e., the thread dies).
Class ConsumeInteger— — a  subclass  of threading.Thread— — consists  of
attribute sharedObject, a constructor (lines 11– – 15) and a run method (lines 17– – 29).
The constructor initializes attribute sharedObject to refer to the Unsynchronized-
Integer object passed as an argument. 
1
# Fig. 19.4: ProduceInteger.py
2
# Class that produces integers
3
4
import threading
5
import random
6
import time
7
8
class ProduceInteger( threading.Thread ):
9
"""Thread to produce integers"""
10
11
def __init__( self, threadName, sharedObject ):
12
"""Initialize thread, set shared object"""
13
14
threading.Thread.__init__( self, name = threadName )
15
self.sharedObject = sharedObject
16
17
def run( self ):
18
"""Produce integers in range 1-10 at random intervals"""
19
20
for i in range( 1, 11 ):
21
time.sleep( random.randrange( 4 ) )
22
self.sharedObject.setSharedNumber( i )
23
24
print self.getName(), "finished producing values"
25
print "Terminating", self.getName()
Fig. 19.4
Fig. 19.4
Fig. 19.4
Fig. 19.4
An integer-producer thread.
1
# Fig. 19.5: ConsumeInteger.py
2
# Class that consumes integers
Fig. 19.5
Fig. 19.5
Fig. 19.5
Fig. 19.5
An integer-consumer thread (part 1 of 2).
How to C#: Basic SDK Concept of XDoc.PDF for .NET
You may add PDF document protection functionality into your C# program. To be specific, you can edit PDF password and digital signature, and set PDF file
create a pdf signature file; sign pdf
VB.NET PDF: Basic SDK Concept of XDoc.PDF
You may add PDF document protection functionality into your VB.NET program. To be specific, you can edit PDF password and digital signature, and set PDF file
adding signature to pdf; create pdf signature field
756
Multithreading
Chapter 19
© Copyright 1992–2002 by Deitel & Associates, Inc. All Rights Reserved. 8/21/01
Class ConsumeInteger’s run method consists of a for structure that loops ten
times to read values from the UnsynchronizedInteger object to which sharedOb-
ject refers. Each iteration of the loop invokes function time.sleep to put the Con-
sumeInteger object into the sleeping state for a random time interval between 0 and 3
seconds. Next, the thread calls the getSharedNumber method to get the value of the
shared object’s data member. Then, the thread adds to variable sum the value returned by
getSharedInt (line 25). When the loop completes, the ConsumeInteger thread dis-
plays a line in the command window indicating that it has finished consuming data and ter-
minates (i.e., the thread dies).
Class UnsynchronizedInteger’s setSharedNumber method (lines 14– – 19)
and getSharedNumber  method (lines 21– – 28) do not synchronize access to  instance
variable sharedNumber (created in line 12). Ideally, we would like every value pro-
duced  by  the ProduceInteger  object  to  be  consumed  exactly  once by  the Con-
sumeInteger object. However, the output of Fig.19.3 reveals that the values 1, 6, 7, 8
and 10 are lost (i.e., never seen by the consumer) and the values 2, 4 and 9 are retrieved
more than once by the consumer. 
3
4
import threading
5
import random
6
import time
7
8
class ConsumeInteger( threading.Thread ):
9
"""Thread to consume integers"""
10
11
def __init__( self, threadName, sharedObject ):
12
"""Initialize thread, set shared object"""
13
14
threading.Thread.__init__( self, name = threadName )
15
self.sharedObject = sharedObject
16
17
def run( self ):
18
"""Consume 10 values at random time intervals"""
19
20
sum = 0            # total sum of consumed values
21
22
# consume 10 values
23
for i in range( 10 ):
24
time.sleep( random.randrange( 4 ) )
25
sum += self.sharedObject.getSharedNumber()
26
27
print "%s retrieved values totaling: %d" % \
28
( self.getName(), sum )
29
print "Terminating", self.getName()
1
# Fig. 19.6: UnsynchronizedInteger.py
2
# Unsynchronized access to an integer
3
Fig. 19.6
Fig. 19.6
Fig. 19.6
Fig. 19.6
Unsynchronized integer value class (part 1 of 2). 
Fig. 19.5
Fig. 19.5
Fig. 19.5
Fig. 19.5
An integer-consumer thread (part 2 of 2).
VB.NET PDF Library SDK to view, edit, convert, process PDF file
NET program. Password, digital signature and PDF text, image and page redaction will be used and customized. PDF Annotation Edit.
pdf add signature field; pdf will signature
C# Create PDF Library SDK to convert PDF from other file formats
can add some additional information to generated PDF file. What's more, you can also protect created PDF file by adding digital signature (watermark) on PDF
add a signature to a pdf file; add signature block to pdf
Chapter 19
Multithreading
757
© Copyright 1992–2002 by Deitel & Associates, Inc. All Rights Reserved. 8/21/01
In fact, method getSharedNumber must perform some “ “ tricks”  to make the output
accurately reflect the value of the data member. Line 24 assigns the value of data member
sharedNumber to variable tempNumber. Lines 25– – 28 then use the value of temp-
Number to print the message and return the value. If we did not use a temporary variable
in this way, the following scenario could occur. The consumer could call method get-
SharedNumber and print a message that displays the value of the data member. The
interpreter might then switch out the consumer thread for the producer thread. The producer
thread might then change the value of sharedNumber any number of times by calling
method setSharedNumber. Eventually, the interpreter switches the consumer back in
and method getSharedNumber returns a value different that the value printed before
the consumer was switched out.
This example clearly demonstrates that access to shared data by concurrent threads
must be controlled carefully or a program may produce incorrect results. To solve the prob-
lems of lost data and doubled data in the previous example, we must synchronize access to
the shared data for the concurrent producer and consumer threads.
19.7 Producer/Consumer Relationship With Thread 
Synchronization
The program in Fig. 19.7 demonstrates a producer and a consumer accessing a shared cell
of memory with synchronization, so that the consumer consumes exactly one time after the
producer produces each value. The program differs only in that it passes an object of class
4
import threading
5
6
class UnsynchronizedInteger:
7
"""Class that provides unsynchronized access an integer"""
8
9
def __init__( self ):
10
"""Initialize shared number to -1"""
11
12
self.sharedNumber = -1
13
14
def setSharedNumber( self, newNumber ):
15
"""Set value of integer"""
16
17
print "%s setting sharedNumber to %d" % \
18
( threading.currentThread().getName(), newNumber )
19
self.sharedNumber = newNumber
20
21
def getSharedNumber( self ):
22
"""Get value of integer"""
23
24
tempNumber = self.sharedNumber
25
print "%s retrieving sharedNumber value %d" % \
26
( threading.currentThread().getName(), tempNumber )
27
28
return tempNumber
Fig. 19.6
Fig. 19.6
Fig. 19.6
Fig. 19.6
Unsynchronized integer value class (part 2 of 2). 
758
Multithreading
Chapter 19
© Copyright 1992–2002 by Deitel & Associates, Inc. All Rights Reserved. 8/21/01
SynchronizedInteger to the producer and consumer. Classes ProduceInteger
and ConsumeInteger are identical to the previous section.
1
# Fig. 19.7: fig19_07.py
2
# Show multiple threads modifying shared object.
3
4
from SynchronizedInteger import SynchronizedInteger
5
from ProduceInteger import ProduceInteger
6
from ConsumeInteger import ConsumeInteger
7
8
# initialize number and threads
9
number = SynchronizedInteger()
10
producer = ProduceInteger( "Producer", number )
11
consumer = ConsumeInteger( "Consumer", number )
12
13
print "Starting threads...\n"
14
15
# start threads
16
producer.start()
17
consumer.start()
18
19
# wait for threads to terminate
20
producer.join()
21
consumer.join()
22
23
print "\nAll threads have terminated."
Fig. 19.7
Fig. 19.7
Fig. 19.7
Fig. 19.7
Threads modifying a synchronized shared object (part 1 of 2).
Chapter 19
Multithreading
759
© Copyright 1992–2002 by Deitel & Associates, Inc. All Rights Reserved. 8/21/01
Class SynchronizedInteger (Fig. 19.8)  contains  three  attributes— — shared-
Numberwriteable and threadCondition, a condition variable. Method set-
SharedNumber uses the condition variable to determine if the thread that calls the
method can write to the shared memory location. Method getSharedNumber uses the
condition variable to determine if the calling thread can read from the shared memory loca-
tion. Line 14 creates the thread condition variable by invoking the threading.Condi-
tion constructor. Because no argument (i.e., an underlying lock) is passed to the condition
variable’s constructor, a new lock will be created for the condition variable.
Starting threads...
Producer setting sharedNumber to 1
Consumer retrieving sharedNumber value 1
Producer setting sharedNumber to 2
Consumer retrieving sharedNumber value 2
Producer setting sharedNumber to 3
Consumer retrieving sharedNumber value 3
Producer setting sharedNumber to 4
Consumer retrieving sharedNumber value 4
Producer setting sharedNumber to 5
Consumer retrieving sharedNumber value 5
Producer setting sharedNumber to 6
Consumer retrieving sharedNumber value 6
Producer setting sharedNumber to 7
Consumer retrieving sharedNumber value 7
Producer setting sharedNumber to 8
Consumer retrieving sharedNumber value 8
Producer setting sharedNumber to 9
Consumer retrieving sharedNumber value 9
Producer setting sharedNumber to 10
Producer finished producing values
Terminating Producer
Consumer retrieving sharedNumber value 10
Consumer retrieved values totaling: 55
Terminating Consumer
All threads have terminated.
1
# Fig. 19.8: SynchronizedInteger.py
2
# Synchronized access to an integer with condition variable
3
4
import threading
5
6
class SynchronizedInteger:
7
"""Class that provides synchronized access an integer"""
8
9
def __init__( self ):
10
"""Set shared number, write flag and condition variable"""
Fig. 19.8
Fig. 19.8
Fig. 19.8
Fig. 19.8
Synchronized integer value class (part 1 of 2).
Fig. 19.7
Fig. 19.7
Fig. 19.7
Fig. 19.7
Threads modifying a synchronized shared object (part 2 of 2).
760
Multithreading
Chapter 19
© Copyright 1992–2002 by Deitel & Associates, Inc. All Rights Reserved. 8/21/01
The constructor (lines 9– – 14) creates attribute writeable and initializes its value to
1.  The  class’  condition  variable— — threadCondition— protects  access  to  attribute
writeable. If writeable is 1, a producer can place a value into variable shared-
Number. However, this means that a consumer currently cannot read the value of
sharedNumber. If  writeable is 0, a consumer can read a value from variable
11
12
self.sharedNumber = -1  
13
self.writeable = 1      # the value can be changed
14
self.threadCondition = threading.Condition()
15
16
def setSharedNumber( self, newNumber ):
17
"""Set value of integer--blocks until lock acquired"""
18
19
# block until lock released then acquire lock
20
self.threadCondition.acquire()   
21
22
# while not producer’s turn, release lock and block
23
while not self.writeable:
24
self.threadCondition.wait()
25
26
# (lock has now been re-acquired)
27
28
print "%s setting sharedNumber to %d" % \
29
( threading.currentThread().getName(), newNumber )
30
self.sharedNumber = newNumber
31
32
self.writeable = 0             # allow consumer to consume
33
self.threadCondition.notify()  # wake up a waiting thread
34
self.threadCondition.release() # allow lock to be acquired
35
36
def getSharedNumber( self ):
37
"""Get value of integer--blocks until lock acquired"""
38
39
# block until lock released then acquire lock
40
self.threadCondition.acquire()   
41
42
# while producer’s turn, release lock and block
43
while self.writeable:
44
self.threadCondition.wait()   
45
46
# (lock has now been re-acquired)
47
48
tempNumber = self.sharedNumber
49
print "%s retrieving sharedNumber value %d" % \
50
( threading.currentThread().getName(), tempNumber )
51
52
self.writeable = 1             # allow producer to produce
53
self.threadCondition.notify()  # wake up a waiting thread
54
self.threadCondition.release() # allow lock to be acquired
55
56
return tempNumber
Fig. 19.8
Fig. 19.8
Fig. 19.8
Fig. 19.8
Synchronized integer value class (part 2 of 2).
Documents you may be interested
Documents you may be interested