C++ process new
-
Upload
- -
Category
Technology
-
view
639 -
download
4
description
Transcript of C++ process new
Brief Review to C++ / Process / Thread
石宗胤 , 周惟中 , 蘇文鈺2009/09/14
Outline
• C++• Process• Thread
C++
A Simple Example
• Hello World#include <iostream>
using namespace std;
int main(){
cout << "Hello! World!\n"; cout << “Hello! C++!\n";
return 0; }
Namespace• When programs grow too large, it is very difficult to manage the names of
variables, functions, classes. It is better to use namespace to resolve the troubles.
• Namespace is like a container. Namespaces allow to group entities like classes, objects and functions under a name. This way the global scope can be divided in "sub-scopes", each one with its own name. For example, variables of the same name will not conflict with each other when they are in distinct namespaces.
• The format of namespaces is:
namespace identifier{
entities;}
Namespace Example#include <iostream>using namespace std;
namespace integer{ int x = 5; int y = 10;}
namespace floating{ double x = 3.67; double y = 2e-1;}
int main () { using integer::x; using floating::y; cout << x << endl; cout << y << endl; cout << floating::y << endl; cout << integer::x << endl; return 0;}
Please find the answer!! Do you have other ways of implementing
this?
Variables & Data Types
• Declaration of variables– Type– Identifier
• A sequence of one or more letters, digits or underscore characters (_)
• Have to begin with a letter or underscore characters (_)• Cannot match any reserved keywords of the C++
language– catch, char, class, const etc
int a; float mynumber; int a; float mynumber; int a; float mynumber;
int a;float mynumber;
TypesName Description Size* Range*
char Character or small integer. 1byte signed: -128 to 127unsigned: 0 to 255
short int (short) Short Integer. 2bytes signed: -32768 to 32767unsigned: 0 to 65535
int Integer. 4bytessigned: -2147483648 to 2147483647unsigned: 0 to 4294967295
long int (long) Long integer. 4bytessigned: -2147483648 to 2147483647unsigned: 0 to 4294967295
bool Boolean value. It can take one of two values: true or false. 1byte true or false
float Floating point number. 4bytes +/- 3.4e +/- 38 (~7 digits)
double Double precision floating point number. 8bytes +/- 1.7e +/- 308 (~15 digits)
long double Long double precision floating point number. 8bytes +/- 1.7e +/- 308 (~15 digits)
wchar_t Wide character. 2 or 4 bytes 1 wide character
Literal Constant
• Integer Numerals– 75, 75u, 75l, 75ul, 0113, 0x4b
• Floating-Point Numerals– 3.1415, 6.02e23, 1.6e-19, 3.0, 3.1415l, 6.02e23f
• Characters– ‘x’, ‘\n’
• Strings– "Hello world“, “one\ntwo\nthree”
• Boolean Values– true, false
OperatorsLevel Operator Description Grouping1 :: scope Left-to-right
2 () [] . -> ++ -- dynamic_cast static_cast reinterpret_cast const_cast typeid postfix Left-to-right
3++ -- ~ ! sizeof new delete unary (prefix)
Right-to-left* & indirection and reference (pointers)+ - unary sign operator
4 (type) type casting Right-to-left5 .* ->* pointer-to-member Left-to-right6 * / % multiplicative Left-to-right7 + - additive Left-to-right8 << >> shift Left-to-right9 < > <= >= relational Left-to-right10 == != equality Left-to-right11 & bitwise AND Left-to-right12 ^ bitwise XOR Left-to-right13 | bitwise OR Left-to-right14 && logical AND Left-to-right15 || logical OR Left-to-right16 ?: conditional Right-to-left
17 = *= /= %= += -= >>= <<= &= ^= |= assignment Right-to-left
18 , comma Left-to-right
Operators (Cont’)
• Grouping– Left to right
• a + b + c– (a + b) + c
– Right to left• a += b += c
– b = b + c– a = a + b
Basic Input and Output• Standard Output (cout)
– cout << "Output sentence";– cout << “x” << “=” << x << endl;
• Standard Input (cin)– cin >> age;– cin >> a >> b;
• cin and strings– cin extraction stops reading as soon as any blank space character is
encountered.– getline (cin, mystr) can also be used such that a line can be read at a
time; • stringstream
– stringstream(mystr) >> myint;
Basic Input and Output (Cont’)//io.cpp#include <iostream>
using namespace std;
int main(){
int a, b;
cout << "input a & b: ";
cin >> a >> b;
cout << "a + b = " << a + b << endl;
return 0;}
Io.cpp
Program Flow Control
• Conditional structure– if, else
• Iteration structures (loops)– while– do-while– for
• Jump statements– break– continue– goto
• The selective structure– switch
Program Flow Control (Cont’)//flow.cpp #include <iostream>
using namespace std;
int main(){
int a, b;int c = 0;int sum = 0;
cout << "input a & b: ";cin >> a >> b;
if(a == b)cout << "a == b" << endl;
elsecout << "a != b" << endl;
for(int i=0;i<a;i++)sum += i;
cout << "sum = " << sum << endl;
Flow.cpp
Program Flow Control (Cont’)while(1){
cout << "c = " << c << endl;
switch(c){
case 0:c ++;break;
case 1:c ++;
case 2:c ++;break;
}if(c < 2)
continue;else
break;
cout << "not excute" << endl;}return 0;
}
Flow.cpp
Functions
• A group of statements that are executed when the function is called from some point of the program.
• Format– type name ( parameter1, parameter2, ...)
{ statements } int addition (int a, int b){
int r;r = a + b;return (r);
}
result = addition(a, b)
Overloading• In C++, If more than one definitions for a function name or an operator in
the same scope are specified, that function name or operator is overloaded.
• In such cases, the compiler determines the most appropriate definition by comparing the argument types specified in the definitions to call the function or operator. Hence, we can the same name to more than one functions if those functions have either a different number of parameters or different types in their parameters.
int addition (int a, int b);float addition (float a, float b);
int ir, ia, ib;float fr, fa, fb;
ir = addition(ia, ib);fr = addition(fa, fb);
Operators about overloading• You can overload any of the following operators:
– +, -, *, /, %, ^, &, |, ~ ,! =, <, >, +=, -=, *=, /=, %= ,^=, &=, |=, <<, >>, <<=, >>=, ==, !=, <=, >=, &&, ||, ++, -- , ->*, -> ,( ), [ ], new, delete, new[] and delete[]
– In the above, () is the function call operator and [] is the subscript operator.
• You can overload both the unary and binary forms of the following operators: +, -, *, & .
• You cannot overload the following operators: ., .*, :: and ?:.
• You cannot overload the preprocessor symbols such as # and ##.
Compound Data Types
• Arrays– int a[10]; a[0] == 0;– int b[10][10];
• Character Sequences– char c[] = “test sequence”;
0 1 2a …
Compound Data Types (Cont’)• Pointers
– int a = 10;– int *p_a = &a; *p_a == 10;– int **p_p_a = &p_a; **p_p_a == 10;
10
56
104
5652 60
104100 108
a
p_a
p_p_a
Compound Data Types (Cont’)• Dynamic Memory
– 1D array• int *a = new int[10];• delete[] a;
– 2D array• int **b = new int*[10];• for(int i=0;i<10;i++) b[i] = new int[10];• for(int i=0;i<10;i++) delete[] b[i];• delete[] b;
0 1 2
0 1 2
0
1
.
.
.
.
.
.
b
Compound Data Types (Cont’)
• Data Structuresstruct example {
int a;float b;char c[4];
};
example tmp;tmp.a = 10;tmp.b = 3.14;tmp.c[0] = ‘a’;
Class
• An expanded concept of conventional data structure. Instead of holding only data, it can also hold both functions.
• An object is an instantiation of a class. In terms of variables, a class would be regarded as one of types, and an object would be regarded as the corresponding variable.
• All data and functions in a class is called members of the class.• Format:
class class_name {access_specifier_1:
member1;access_specifier_2:
member2; ... } object_name;
Class Example#include <iostream>using namespace std;class CRectangle {
private:int *width, *height;
public:CRectangle ();CRectangle (int,int);~CRectangle ();int area () {return (*width * *height);}friend CRectangle duplicate (CRectangle);
};
CRectangle::CRectangle (){width = new int;height = new int;
}
CRectangle::CRectangle (int a, int b){width = new int;height = new int;*width = a;*height = b;
}
CRectangle::~CRectangle () {delete width;delete height;
}
Class Example
CRectangle duplicate (CRectangle rectparam) { CRectangle rectres; *(rectres.width) = (*(rectparam.width))*2; *(rectres.height) = (*(rectparam.height))*2; return (rectres);
}
int main () {CRectangle rect(2, 3);Crectangle rectb;
rectb = duplicate (rect);
cout << rectb.area();
return 0; }
Class (Cont’)
• Access specifier– public
• members of a class that are accessible from anywhere where the object is visible.
– private• members of a class that are accessible only from within
other members of the same class or from their friends.
– protected• Members of a class that are accessible from members of
their same class and from their friends, but also from members of their derived classes.
Class (Cont’)
• Constructor– It is called whenever a new object of this class is
created.• Destructor
– It is called when an object is to be destroyed,• if its scope of existence has finished (for example, if it
was defined as a local object within a function and the function ends.)
• if it is an object dynamically assigned and then released using the operator delete.
Inheritance
• Inheritance allows to create classes which are derived from other classes so that they can automatically include some of its "parent's" members, plus its own members.
Inheritance example
class CPolygon {protected:
int width, height;public:
void set_values (int a, int b) { width=a; height=b;} };
class CRectangle: public CPolygon {public:
int area () { return (width * height); } };
Inheritance (Cont’)
• The different access types according to who can access them in the following way
Access public protected privatemembers of the same class yes yes yes
members of derived classes yes yes no
not members yes no no
Virtual Member
• A member of a class that can be redefined in its derived classes is called a virtual member.
class CPolygon {protected:
int width, height;public:
void set_values (int a, int b) { width=a; height=b;}virtual int area() {return 0;}
};
class CRectangle: public CPolygon {public:
int area () { return (width * height); } };
Virtual Member (Cont’)
• Pure virtual member– A member of a class that must be redefined in its
derived classes is called a pure virtual member.class CPolygon {
protected:int width, height;
public:void set_values (int a, int b) { width=a; height=b;}virtual int area() = 0;
};
class CRectangle: public CPolygon {public:
int area () { return (width * height); } };
Template
• Function templates– It is about the fact that special functions that can
operate with generic types.– One can create a function template whose
functionality can be adapted to more than one type or classes.
– Format:• template <class identifier> function_declaration;• template <typename identifier> function_declaration;
Template (Cont’)
– Exampletemplate <class myType>myType GetMax (myType a, myType b) {
return (a>b?a:b);}
int x,y;GetMax <int> (x,y);
Template (Cont’)
• Class templates– A class having members that use template
parameters as their types.– Example
template <class T> class mypair {
T values [2]; public:
mypair (T first, T second) { values[0]=first; values[1]=second; }
};
mypair<int> myobject (115, 36);
Template (Cont’)
• Non-type parameters for templates– Templates can have regular type parameters– Example
template <class T, int N> class mysequence {
T memblock [N]; public:
void setmember (int x, T value); T getmember (int x);
};
mysequence <double,5> myfloats;
template <class T=char, int N=10> class mysequence {..};
Reference
• C++ Language Tutorial– http://www.cplusplus.com/doc/tutorial/
• XL C/C++ V8.0– http://publib.boulder.ibm.com/infocenter/comph
elp/v8v101/index.jsp?topic=/com.ibm.xlcpp8a.doc/language/ref/overl.htm
• C++ 學習筆記– http://caterpillar.onlyfun.net/Gossip/CppGossip/C
ppGossip.html
Process
Process
• In UNIX, Process is a program which has a independent memory space and execute independently. No matter it is a system task or a user task, it is finished by respective Process.
• In UNIX, every process has a unique id called process id (pid).
• Each process is created by its parent process. After finishing its task, it should release all occupied system resource and exit.
Process (Cont’)
• fork-and-exec is the execution mode of all processes in UNIX.
• When the system is boot up, the first executed process is init and its pid is 1.
• Then init executes each process through fork-and-exec.
Process (Cont’)
• Kill: Kill a process by number (-SIGNAL: send a signal to a process specified by its pid)
• killall: Send a signal to a process by name • ps:Used to report the status of one or more processes. (-aux:
list every process)• pstree:Display the tree of running processes. (-Aup: list user
and pid, print using ASCII)• top:Displays the processes that are using the most CPU
resources. (-u username)• nice/renice: set priority of a process (max -20 ~ min 19)
– only superuser can set -20~-1– normal users can only lower its priority (0~19)
Process Programming
• fork()– It is the only way a new process can be created by Unix
kernel.– It is called once, returns twice.– Returns
• 0 in child, process ID of child in parent, and -1 on error.
– Both child and parent continue their executing with the instruction that follows the call to fork()
– It doesn't perform a complete copy of parent's data, stack and heap. It's shared by both and have the protection changed by kernel to read-only. It's COW(copy-on-write).
Process Programming (Cont’)
• The differences between parent/child– the return value from fork()– the process IDs, parent IDs– the child's tms_utime, tms_stime, tms_cutime,
tms_ustime are set to 0– file locks not inherited by the child
Process Programming (Cont’)//fork.c#include <sys/types.h>#include <unistd.h>#include <stdio.h>#include <stdlib.h>
int glob = 6;char buf[] = "a write to stdout\n";
int main(){ int var; pid_t pid;
var = 88; if(write(STDOUT_FILENO, buf, sizeof(buf)-1) != sizeof(buf) - 1){ printf("write error"); exit(1); }
Fork.c
Process Programming (Cont’) printf("before fork\n");
if( (pid = fork()) < 0){ printf("fork error"); exit(1); } else if (pid == 0){ //this is child glob++; var++; }else sleep(2); //this is parent
printf("pid = %d, glob = %d, var = %d\n", getpid(), glob, var); exit(0);
}
Fork.c
Process Programming (Cont’)//forkwice.c#include <sys/types.h>#include <unistd.h>#include <stdio.h>#include <stdlib.h>
int main(){ pid_t pid;
if( (pid = fork()) < 0){ printf("fork error"); exit(1); } else if (pid == 0){ //this is first child if( (pid = fork()) < 0){ printf("fork error"); exit(1); }else if (pid > 0) exit(0); //parent from second fork == first child
Forkwice.c
Process Programming (Cont’)
//now we're the second child, our parent becomes init sleep(1); printf("second child, parent pid = %d\n", getppid()); exit(0); } //original parent, it waits if(waitpid(pid, NULL, 0) != pid){ //wait for first child printf("waitpid error"); exit(1); }
//note that the shell prints its prompt when the //original process terminates, which is before // the second child prints its parent process ID exit(0);
}
Forkwice.c
Process Programming (Cont’)
• wait() and waitpid()– block if all of its children are running– return immediately with the term status of a child (if a
child has terminated)• Differences:
– wait can block the caller until a child process terminates.
– waitpid has an option that prevents it from blocking.– waitpid has a number of options that control which
process it waits for.
Process Programming (Cont’)//wait.c#include <sys/types.h>#include <sys/wait.h>#include <unistd.h>#include <stdio.h>#include <stdlib.h>
int main(){ pid_t pid; int status;
if( (pid = fork()) < 0){ printf("fork error"); exit(1); } else if (pid == 0){ //this is child// exit(7); //normal abort(); //generates SIGABRT// status /= 0; //generates SIGFPE }
Wait.c
Process Programming (Cont’) //this is parant if(wait(&status) != pid){ printf("wait error"); exit(1); } // print status if(WIFEXITED(status)) printf("normal termination, exit status = %d\n", WEXITSTATUS(status)); else if (WIFSIGNALED(status)) printf("abnormal termination, signal number = %d\n", WTERMSIG(status)); else if (WIFSTOPPED(status)) printf("child stopped, signal number= %d\n", WSTOPSIG(status)); exit(0);
}
Wait.c
Process Programming (Cont’)
• exec:– When a process calls exec functions, the process is completely
replaced by the new program.– The process ID doesn't change: exec merely replaces the current
process(its text, data, heap, and stack segments).• Family
– int execl(const char *path, const char *arg, ...)– int execlp(const char *file, const char *arg, ...)– int execle(const char *path, const char *arg , ..., char * const
envp[])– int execv(const char *path, char *const argv[])– int execvp(const char *file, char *const argv[])
Process Programming (Cont’)//exe.c#include <sys/types.h>#include <sys/wait.h>#include <stdlib.h>#include <stdio.h>#include <unistd.h>
char *env_init[] = { "USER=unknown", "PATH=/tmp", NULL};int main(){ pid_t pid; if( (pid = fork()) < 0 ){ printf("fork error"); exit(1); }else if (pid == 0){ //child///* //specify pathname, specify environment if(execle("/home/starryalley/Desktop/Linux_process_signal/example/echoall", "echoall", "arg1", "arg 2", "my arg 3", (char*)0, env_init) < 0){ printf("execle error"); exit(1); }//*/
Exe.c
Process Programming (Cont’)/* //specify filename, inherit environment if(execlp("./echoall", "echoall", "only 1 arg", (char*)0) < 0){ printf("execlp error"); exit(1); }*/ } if(waitpid(pid, NULL, 0) < 0){ printf("wait error"); exit(1); }}
Exe.c
Thread
Outline
• Thread– Introduction– Identification– Creation– Termination
• Thread Synchronization– Mutex
Thread
• A thread (sometimes known as an execution context or a lightweight process) is a single sequential flow of control within a process.
• A typical UNIX process have a single thread of control.– Each process is doing only one thing at a time.
• Multithreading means that it can have more than one thread of control.– Each process can do many things at a time.
Benefits
1. Simplify a design that need to deal with asynchronous events.
2. Resource sharing3. Improve SOME program throughput
– E.g. blockable program
4. Improve interactive time
Resources of thread• Proprietary
– Identity• Thread ID
– A set of Registers– A Stack– A scheduling priority and policy– Signal mask– Errno variable– Thread-specific data
• Shared– Text of executable program– Program’s global and heap memory– Stacks– File descriptors
Thread Standard
• Defined in IEEE POSIX.1-2001• POSIX Thread or pthread• How to detect?
– #ifdef _POSIX_THREADS– sysconf( _SC_THREADS )
Thread Identification
• Process ID is unique in the system; thread ID is unique in the process
• Must use function to manipulate thread ID• Q: Can we print thread ID directly?
– Ans: NO
#include <pthread.h>
int pthread_equal( pthread_t tid1, pthread_t tid2 ) Returns: nonzero if equal, 0 otherwise
pthread_t pthread_self()
Thread Creation• pthread_create()
• Return error code and don’t set errno when failure• No guarantee on the running order of the threads created and the
threads creating
#include <pthread.h>
int pthread_create( pthread_t * restrict tidp, const pthread_attr_t* restrict attr, void * (*start_rtn)(void), void* restrict arg )
Return: 0 if OK, error number on failure
Example
• See print_id.c• -D_REENTRANT –lpthread
Q&A:1. Why sleep( 1 ) is needed?2. Why pthread_self() instrad of ntid?
Example(Cont’)//print_id.c#include <stdio.h>#include <unistd.h>#include <sys/types.h>#include <string.h>#include <pthread.h>
pthread_t ntid;
void printids( const char* s ){
pid_t pid;pthread_t tid;
pid = getpid();tid = pthread_self();
printf( "%s pid %u tid %u (0x%x)\n", s, (unsigned int) pid , (unsigned int) tid, (unsigned int) tid );}
Print_id.c
Example(Cont’)void* thr_fn( void* arg ){
printids( "New thread: " );return ((void*) 0);
}
int main(){
int err = pthread_create( &ntid, NULL, thr_fn, NULL );
if ( 0 != err ) {fprintf( stderr, "can't create thread: %s\n", strerror( err ) );
}
printids( "main thread:" );sleep( 1 );
return 0;}
Print_id.c
Other Platforms• Solaris 9
main thread: pid 7225 tid 1 (0x1)new thread: pid 7225 tid 4 (0x4)
• FreeBSD 5.2.1 main thread: pid 14954 tid 134529024 (0x804c000)
new thread: pid 14954 tid 134530048 (0x804c400) • MacOS Darwin 7.4.0
main thread: pid 779 tid 2684396012 (0xa000a1ec) new thread: pid 779 tid 25166336 (0x1800200) • Linux 2.4.22
new thread: pid 6628 tid 1026 (0x402) main thread: pid 6626 tid 1024 (0x400)
Thread Termination
• How can a thread exit?1. Voluntary
1. Return from the start routine2. Call pthread_exit
2. Involuntary1. Canceled by another thread in the same process
Thread Termination - Voluntary
• Set/Get return value#include <pthread.h>
void pthread_exit( void* rval_ptr );int pthread_join( pthread_t thread, void** rval_ptr );
Return: 0 if OK, error number on failure
Thread Termination - Voluntary
• Example– See get_rtnv.c
• Be careful of your Memory Usage– See get_smem_rtnv.c
Example//get_rtnv.c#include <stdio.h>#include <sys/types.h>#include <string.h>#include <pthread.h>
void* thr_fn1( void* arg ){
printf( "thread 1 returning\n" );return ((void*) 1);
}
void* thr_fn2( void* arg ){
printf( "thread 2 returning\n" );return ((void*) 2);
}
Get_rtnv.c
Example(Cont’)int main(){
int err;pthread_t tid1, tid2;void* tret;
err = pthread_create( &tid1, NULL, thr_fn1, NULL );
if ( 0 != err ) {fprintf( stderr, "Can't create thread 1: %s\n", strerror( err ) );return 1;
}
err = pthread_create( &tid2, NULL, thr_fn2, NULL );
if ( 0 != err ) {fprintf( stderr, "Can't create thread 2: %s\n", strerror( err ) );return 1;
}
Get_rtnv.c
Example(Cont’)err = pthread_join( tid1, &tret );
if ( 0 != err ) {fprintf( stderr, "Can't join with thread 1: %s\n", strerror( err ) );return 1;
}printf( "thread 1 exit code %d\n", (int) tret );
err = pthread_join( tid2, &tret );
if ( 0 != err ) {fprintf( stderr, "Can't join with thread 2: %s\n", strerror( err ) );return 1;
}
printf( "thread 2 exit code %d\n", (int) tret );return 0;
}
Get_rtnv.c
Summary
Process Primitive
Thread Primitive Description
fork pthread_create Create a flow of control
exit pthread_exit Exit from an existing flow of control
waitpid pthread_join Get exit status from flow of control
Thread Synchronization
• Threads share the same memory space.
• Modification takes more than one memory cycle.– E.g. Memory read is
interleaved between the memory write cycles.
Thread Synchronization
• Solution– Lock the critical sections
Mutex• Mutual-exclusive• A lock set (lock) before accessing a shared
resource and releaseed (unlock) when a job is done.– Only one thread will proceed at a time.
#include <pthread.h>
pthread_mutex_tPTHREAD_MUTEX_INITIALIZERint pthread_mutex_init( pthread_mutex_t* restrict mutex, const pthread_mutexattr_t* restrict attr )int pthread_mutex_destroy( pthread_mutex_t* mutex )
Return: 0 if OK, error number on failure
Mutex
• Mutex operation#include <pthread.h>
int pthread_mutex_lock( pthread_mutex_t* restrict mutex )int pthread_mutex_unlock( pthread_mutex_t* mutex )int pthread_mutex_trylock( pthread_mutex_t* mutex )
Return: 0 if OK, error number on failure
Example Mutex//mutex_cnt.c#include <stdlib.h>#include <stdio.h>#include <pthread.h>
struct foo {int f_count;pthread_mutex_t f_lock;
};
struct foo* foo_alloc(){
struct foo* fp;if ( (fp = malloc(sizeof( struct foo ))) != NULL ) {
fp->f_count = 1;if ( pthread_mutex_init( &fp->f_lock, NULL ) != 0 ) {
free( fp );return (NULL);
}}return (fp);
}
Mutex_cnt.c
Example Mutex(Cont’)void foo_hold( struct foo* fp ){
pthread_mutex_lock( &fp->f_lock );fp->f_count++;pthread_mutex_unlock( &fp->f_lock );
}
void foo_rele( struct foo* fp ){
pthread_mutex_lock( &fp->f_lock );
if ( --fp->f_count == 0 ) {pthread_mutex_unlock( &fp->f_lock );pthread_mutex_destroy( &fp->f_lock );free( fp );
}else
pthread_mutex_unlock( &fp->f_lock );}
Mutex_cnt.c
Example Mutex(Cont’)void* thr_fn( void* arg ){
struct foo *fp = (struct foo *)arg;
foo_hold(fp);printf("foo count = %d\n", fp->f_count);foo_rele(fp);pthread_exit( (void*) 0 );
}int main(){
struct foo *fp = foo_alloc();pthread_t tid1, tid2;int i;
pthread_create( &tid1, NULL, thr_fn, fp);pthread_create( &tid2, NULL, thr_fn, fp);pthread_join( tid1, (void*) &i );pthread_join( tid2, (void*) &i );foo_rele(fp);return 0;
}
Mutex_cnt.c
Mutex
• Deadlock– A process/thread is blocked on a resource request
that can never be satisfied.• A thread will be deadlocked if it tries to lock
the same mutex twice.• Some threads may be deadlocked because
each thread needs a resource which is locked by others.
Reference
• The Single UNIX® Specification, Version 2 – http://www.opengroup.org/pubs/online/7908799
/• The Open Group Base Specifications Issue 6
IEEE Std 1003.1, 2004 Edition– http://www.opengroup.org/onlinepubs/00969539
9/• Cpp Reference
– http://www.cppreference.com