例子文件：
/*
this is bill.c
*/
#include  <stdio.h>
void  bill(char *argv)
{
    printf("bill:  %s\n",argv);
}
/*
this is linus.c
*/
#include  <stdio.h>
void  linus(char *argv)
{
    printf("linus:  %s\n",argv);
}
/*
this is mylib.h
*/
void bill(char  *);
void linus(char *);
/*
this is main program
*/
#include  "mylib.h"
int main()
{
    linus("Hello Word");
    exit(0);
}
fuqiang@fuqiang-laptop:~/linuxcexample/ch1$ gcc -c bill.c linus.c
fuqiang@fuqiang-laptop:~/linuxcexample/ch1$ ls *.o
bill.o  linus.o
fuqiang@fuqiang-laptop:~/linuxcexample/ch1$ ls
bill.c  bill.o  linus.c  linus.o  main.c  mylib.h
fuqiang@fuqiang-laptop:~/linuxcexample/ch1$ gcc -c main.c
fuqiang@fuqiang-laptop:~/linuxcexample/ch1$ ls
bill.c  bill.o  linus.c  linus.o  main.c  main.o  mylib.h
fuqiang@fuqiang-laptop:~/linuxcexample/ch1$ gcc -o main main.o linus.o
fuqiang@fuqiang-laptop:~/linuxcexample/ch1$ ./main
linus:  Hello Word
fuqiang@fuqiang-laptop:~/linuxcexample/ch1$ ar crv libmy.a  bill.o linus.o
a - bill.o
a - linus.o
fuqiang@fuqiang-laptop:~/linuxcexample/ch1$ ls
bill.c  bill.o  libmy.a  linus.c  linus.o  main  main.c  main.o  mylib.h
fuqiang@fuqiang-laptop:~/linuxcexample/ch1$ ls libmy.a
libmy.a
fuqiang@fuqiang-laptop:~/linuxcexample/ch1$ nm main
080494dc d _DYNAMIC
080495b0 d _GLOBAL_OFFSET_TABLE_
080484a8 R _IO_stdin_used
        w _Jv_RegisterClasses
080494cc d __CTOR_END__
080494c8 d __CTOR_LIST__
080494d4 d __DTOR_END__
080494d0 d __DTOR_LIST__
080484c4 r __FRAME_END__
080494d8 d __JCR_END__
080494d8 d __JCR_LIST__
080495d8 A __bss_start
080495cc D __data_start
08048460 t __do_global_ctors_aux
08048350 t __do_global_dtors_aux
080495d0 D __dso_handle
        w __gmon_start__
0804845a T __i686.get_pc_thunk.bx
080494c8 d __init_array_end
080494c8 d __init_array_start
080483f0 T __libc_csu_fini
08048400 T __libc_csu_init
        U __libc_start_main@@GLIBC_2.0
080495d8 A _edata
080495dc A _end
08048488 T _fini
080484a4 R _fp_hw
0804829c T _init
08048320 T _start
080495d8 b completed.5982
080495cc W data_start
        U exit@@GLIBC_2.0
08048380 t frame_dummy
080483d0 T linus
080483a4 T main
080495d4 d p.5980
        U printf@@GLIBC_2.0
fuqiang@fuqiang-laptop:~/linuxcexample/ch1$ nm libmy.a

bill.o:
00000000 T bill
        U printf

linus.o:
00000000 T linus
        U printf

一、为什么用线程(Thread)?
    在现阶段应用程序设计技术中，线程扮演很重要的角色，比如好多中间件是基于线程的、JAVA GUI应用等。
    大面积应用采用线程的理由如下：
    1、并行计算
    2、并行I／O处理
    3、异步I／O事件处理
二、什么是线程(Thread)？
    1、先说一下什么是进程（Process)？
      通过学习操作系统的基本原理你可以了解到它的重要性和有用性，主要是提升CPU的处理效率，主要内容有：什么是进程，进程的状态，进程的调度，进程的结构与标识， 进程的空间，进程的上下文切换，进程的处理方法，进程与程序的区别等。
    2、线程是类似进程的，只有大小、粒度的不同
      线程有时也叫轻量级（lightweight)进程,占有比线程更小的空间，切换的代价小，实际情况下依赖于具体的线程系统，它们都有自己的中断方法，关 于中断的技术要引起关注，因为线程的粒度小，有时要引起极大的关注，都可以创建自己的子线程或子进程，在UNIX／LINUX中用fork()创建子线 程，子共亨父的方法也是类同的。
三、Python的线程模块
    有两个thread.py和threading.py,前者是早期的，相对来说简单一些。
    用例子说明如下，注意研究lock是如何形成的
      server.py
    # this is the server
import socket  # networking module
import sys
import thread
# note the globals v and nclnt, and their supporting locks, which are
#    also global; the standard method of communication between threads is
#    via globals
# function for thread to serve a particular client, c
def serveclient(c):
      global v,nclnt,vlock,nclntlock
      while 1:
              # receive letter from c, if it is still connected
              k = c.recv(1)
              if k == ' ': break
              # concatenate v with k in an atomic manner, i.e. with protection
              #    by locks
              vlock.acquire()
              v += k
              vlock.release()
              # send new v back to client
              c.send(v)
              c.close()
              nclntlock.acquire()
              nclnt -= 1
              nclntlock.release()
# set up Internet TCP socket
lstn = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
port = int(sys.argv[1]) # server port number
# bind lstn socket to this port
lstn.bind(('127.0.0.1', 4000))
# start listening for contacts from clients (at most 2 at a time)
lstn.listen(5)
# initialize concatenated string, v
v = ' '
# set up a lock to guard v
vlock = thread.allocate_lock()
# nclnt will be the number of clients still connected
nclnt = 2
# set up a lock to guard nclnt
nclntlock = thread.allocate_lock()
# accept calls from the clients
for i in range(nclnt):
      # wait for call, then get a new socket to use for this client,
      #    and get the client's address/port tuple (though not used)
      (clnt,ap) = lstn.accept()
      # start thread for this client, with serveclient() as the thread's
      #    function, with parameter clnt; note that parameter set must be
      #    a tuple; in this case, the tuple is of length 1, so a comma is
      #    needed
      thread.start_new_thread(serveclient(clnt))
# shut down the server socket, since it's not needed anymore
lstn.close()
# wait for both threads to finish
while nclnt > 0: pass
print 'the final value of v is', v
  client1.py
# simple illustration of thread module
# two clients connect to server; each client repeatedly sends a letter,
# stored in the variable k, which the server appends to a global string
# v, and reports v to the client; k = ' 'means the client is dropping out; when all clients are gone, server prints the final string v
# this is the client; usage is
#    python clnt.py server_address port_number
import socket  # networking module
import sys
# create Internet TCP socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
host = sys.argv[1] # server address
port = int(sys.argv[2]) # server port
# connect to server
s.connect((host,port ))
while(1):
# get letter
        k = raw_input('enter a letter:')
        s.send(k) # send k to server
# if stop signal, then leave loop
        if k == ' ': break
v= s.recv(1024)  # receive v from server (up to 1024 bytes)
print  v
s.close() # close socket
下面是threading的，联系java想一下相关方面 srvr如何？
# simple illustration of threading module
# multiple clients connect to server; each client repeatedly sends a
# value k, which the server adds to a global string v and echos back
# to the client; k = ’’ means the client is dropping out; when all
# clients are gone, server prints final value of v
# this is the server
import socket # networking module
import sys
import threading
# class for threads, subclassed from threading.Thread class
class srvr(threading.Thread):
        # v and vlock are now class variables
        v = ’’
        vlock = threading.Lock()
        id = 0 # I want to give an ID number to each thread, starting at 0
        def __init__(self,clntsock):
              # invoke constructor of parent class
              threading.Thread.__init__(self)
              # add instance variables
              self.myid = srvr.id
              srvr.id += 1
              self.myclntsock = clntsock
      # this function is what the thread actually runs; the required name
      #    is run(); threading.Thread.start() calls threading.Thread.run(),
      #    which is always overridden, as we are doing here
      def run(self):
              while 1:
                    # receive letter from client, if it is still connected
                    k = self.myclntsock.recv(1)
                    if k == ’’: break
                    # update v in an atomic manner
                    srvr.vlock.acquire()
                    srvr.v += k
                    srvr.vlock.release()
                    # send new v back to client
                    self.myclntsock.send(srvr.v)
            self.myclntsock.close()
# set up Internet TCP socket
lstn = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
port = int(sys.argv[1]) # server port number
# bind lstn socket to this port
lstn.bind((’’, port))
# start listening for contacts from clients (at most 2 at a time)
lstn.listen(5)
nclnt = int(sys.argv[2])  # number of clients
mythreads = [] # list of all the threads
# accept calls from the clients
for i in range(nclnt):
      # wait for call, then get a new socket to use for this client,
      #    and get the client’s address/port tuple (though not used)
        (clnt,ap) = lstn.accept()
      # make a new instance of the class srvr
      s = srvr(clnt)
      # keep a list all threads
      mythreads.append(s)
      # threading.Thread.start calls threading.Thread.run(), which we
      #    overrode in our definition of the class srvr
      s.start()
# shut down the server socket, since it’s not needed anymore
lstn.close()
# wait for all threads to finish
for s in mythreads:
      s.join()
print ’the final value of v is’, srvr.v

Most operating systems have a command interpreter or shell, Unix and Linux have many, Windows has the Command Prompt. Erlang has its own shell where you can directly write bits of Erlang code and evaluate (run) them to see what happens. Start the Erlang shell (in Linux or UNIX) by starting a shell or command interpreter in your operating system and typing erl, you will see something.
tut.erl
code--start
-module(tut).
-export([double/1]).
double(X) ->
        2 * X.
code--end
fuqiang@fuqiang-laptop:~$ erl
Erlang (BEAM) emulator version 5.5.5 [source] [async-threads:0] [kernel-poll:false]

Eshell V5.5.5  (abort with ^G)
1> c(tut).
{ok,tut}
2> tut:double(10).
20
3>