（1）开源：有一篇博文里面的观点说开源的东东就意味着免费，其实这是个错误的，开源的东东是可以收费的。但开源本身而言对于一个软件的发展是极为有利的，Linux本身就是一个很好的例子！
（2）跨平台：大多数在Linux环境下开发的程序员都或多或少地接触过Windows平台下的程序开发（这几乎可以是肯定的，君不见Windows的盗版光盘满大街4块钱一张的）。当你在Linux下完成了一个系统，你恐怕潜意识里都在想，这玩意能不能直接在Windows上跑那？因此，从这点来说，即使你现在所设计的系统并不需要考虑跨平台的问题，但是为了将来的长远打算，能跨平台当然不是一件坏事。而像Code::Blocks这样一款IDE软件可以跨Linux和Windows平台，又可以支持Mac系统，有什么理由不值得我们去用一下呢！
（3）IDE本身是用C++写成的：如果你所使用的IDE是用Java写的，就像Eclipse，而你要在上面写开发C++程序，你会什么感觉！要知道Java的虚拟机是用C++写的！- -|||
（4）支持多编译器：这个Happy，不同的编译器对于C++99的标准支持的程度不同，之前用VC6，那就一个崩溃啊，很多程序都无法正常运行，这个好，可以选像GCC、Inter C++、Borland C++、VC++等等，我默认还是用了GCC。
（5）插件式的框架：联想一下Eclipse，这种开发的方式让IDE保留了良好的可扩展性，对于一款开源的IDE而言，这恐怕是最合理的选择了。Code::Blocks有很多核心功能，包括调试功能都是通过插件来实现的，明天去下载个代码格式美化的插件玩玩去，等水平到了，我也想开发个插件，比如什么“坦克大战”，加载到小游戏里面去，哈哈！
（6）升级：几乎每个月都会有更新，非常有生命力的东东！
（7）内嵌可视化设计：可视化开发平台与VB、Delphi、C++ Builder相比，在“傻瓜性”上差了一大截，主要原因在于主流的跨平台图形窗口定位体系都是采用定位“容器”来实现的，这一点一开始可能不会太习惯，但在熟悉之后，设计各种对话框什么的都很得心应手了的。一点点的不直观，但却很容易让你的程序迁移到别的操作系统上面，同时你对窗口设计了解更深入了，还是很值得的！
（8）C++扩展库支持：通过它的一个用以支持Dev C++的插件，可以下载大量的C++开源的扩展库，比如网络操作、图形算法、压缩、加密等等。
（9）多国语言：支持近40国语言，不过并不是默认支持的，语言包文件可以下载后使用
（10）众人的选择：Code::Blocks进入了“SourceForge Community Choice Award”2008年度决赛，“SourceForge”是全球最大的开源社区，这一赛事也被称为“社区最佳选择奖”，可见其拥有一定规模的用户群体，并深受用户的喜爱！

关于安装过程总结起来可以分为以下几个步骤：
1.首先要安装wxGTK，这个是必须的，否则Code::Blocks将无法成功安装。因为Code::Blocks是基于wxWidgets（wxGTK）开发出来的。
wxGTK最新版本下载地址：http://www.wxwidgets.org/downloads/
我所使用的版本下载地址为：
http://nchc.dl.sourceforge.net/sourceforge/wxwindows/wxGTK-2.8.10.tar.gz

2.编译安装wxGTK（以wxGTK-2.8.10为例）
依次输入如下命令进行安装：
tar zxvf wxGTK-2.8.10.tar.gz
cd wxGTK-2.8.10
./configure –enable-xrc –enable-monolithic –enable-unicode
make
make install
其中的make过程时间会相当的长，请耐心等待，如果没有错误提示，说明安装比较顺利！

3.下载Code::Block
Code::Block最新版本的下载地址：http://www.codeblocks.org/downloads/
我所使用的版本下载地址为：
http://ncu.dl.sourceforge.net/sourceforge/codeblocks/codeblocks-8.02-src.tar.bz2

4.编译安装Code::Block（以codeblocks-8.02为例）
依次输入如下命令进行安装：
tar jxf codeblocks-8.02-src.tar.bz2
cd codeblocks-8.02
./configure –prefix=/usr
make
make install
这里面将其安装于/usr下，如果在/usr/local下会提示有些so文件找不到，按照Linux的习惯而言，系统包都是安装在/usr下，而用户使用的应用软件默认安装于/usr/local下，如果不指定话会因为PATH不够，无法包含Lib库的情况，当然可以自己添加。

5.修改库文件路径指向
因为在安装wxGTK时没有指定路径，因此，wxGTK被装到了/usr/local/lib下，当然，如果安装wxGTK时已经指定了路径，即加入“-prefix=/usr”这个参数后，则可以省略这一步。
库文件路径指向方法：
vi /etc/ld.so.conf
在文件最后输入：/usr/local/lib
保存后，运行/sbin/ldconfig
按照上述配置路径就应该没有什么问题，否则就会出现运行Code::Blocks之后，一闪就自动关闭了，本人就是这种情况，通过修改就解决了。

6.验证安装是否正确
可以通过以下操作的输出检索安装是否正确
wx-config –prefix
wx-config –libs
which wx-config

7.创建快捷方式
在桌面上点鼠标右键，选择“创建启动器”，并输入如下路径：
/usr/bin/codeblocks

8.双击启动Code::Block
或直接在终端输入/usr/bin/codeblocks

9.中文语言包
需要下载一个中文语言包：d2school_codeblocks_chinese_locale.7z
下载地址：
http://www.d2school.com/codeblocks/download/d2school_codeblocks_chinese_locale.7z
在Linux下解压后，创建一个目录mkdir -p /usr/share/codeblocks/locale 将解压出来的mo文件复制到下面，再打开就是中文的了，
有人说还需要下面的操作，其实是不需要的，打开之后就是中文了：
启动Code::Blocks，选择SettingsàEnviornmentàViewàInternationalizationà
Chinese (Simplified)即可。

10.更改编译器的默认路径
费了老半天的劲把code::blocks装上去了，兴奋地赶快想敲个HELLO WORLD程序，结果呢，又折腾了半天点了构建、运行…等等按钮都是一点反应都没有。
原因很简单Fedora上编译器默认的安装路径是/usr/lib，但实际上，我们把code::blocks安装到了/usr下面，所以需要把默认的路径改为/usr：settingàcompiler and ddebugeràToolchain executables中将compiler’s installtion directory改为/usr就行了，code::blocks自动检测结果是/usr/lib。

/*pthread_create函数主要完成线程的创建.
   参数解释: 
     thread参数是一个线程标识符,当新创建一个线程的时候,会以此变量记录线程标识符
     attr参数用于设置线程的属性,一般使用时,常为NULL
     start_routine 函数指针,指向一个函数.也就是这个线程所要运行的函数
     arg参数:线程所指向的函数的参数,如果函数不需要参数,设为NULL
*/
int pthread_create(pthread_t *thread,pthread_attr_t *attr, 
void *(*start_routine)(void *),void *arg); 
/*
  pthread_join : 调用pthread_join的线程将等待参数thread所指向的线程
  结束为止，当pthread_join函数返回时，被等待线程的资源被收回。
  参数解释:
   第一个参数为被等待的线程标识符，
   第二个参数为一个用户定义的指针，它可以用来存储被等待线程的返回值
*/
int pthread_join(pthread *thread,void **thread_return); 
/*
   pthread_exit 主要用于结束线程.
   下面主要解释一下pthread_exit的参数 retval .当线程调用pthread_exit时,
   线程将退出,retval中保存需要返回的信息.只要pthread_join中的第二个参数thread_return不是NULL，这个值将被传递给thread_return.
*/
void pthread_exit(void *retval);

下面分析一个实例:

#include <pthread .h>
#include <stdio .h>
#include <errno .h>
#include <string .h>
void *thread_function(void *arg);
char message[] = "Hello World";
int main()
{
	int res;
	pthread_t a_thread;
	void *thread_result;
	res = pthread_create(&a_thread, NULL, thread_function, (void *)message);
	if (res != 0)
	{
		perror("Thread creation failed");
		exit(1);
	}
	printf("Waiting for thread to finish...\n");
	res = pthread_join(a_thread, &thread_result); //pthread_join 阻塞执行的线程直到某线程结束
	if (res != 0)
	{
		perror("Thread join failed");
		exit(1);
	}
	printf("Thread joined, it returned %s\n", (char *)thread_result);
	printf("Message is now %s\n", message);
	exit(0);
}
void *thread_function(void *arg)
{
	printf("thread_function is running. Argument was %s\n", (char *)arg);
	sleep(3);
	strcpy(message, "Bye!");
	pthread_exit("Thank you for the CPU time");
}
</string></errno></stdio></pthread>

当主线程执行到pthread_create时,将创建一个新线程.我们将它称之为子线程
这时将根据cpu将主线程和子线程之间调度
当主线程执行到pthread_join的时候,将阻塞主线程的执行,直到a_thread所标示的子线程执行结束后,再执行主线程

执行结果

将内容改为

LANG=”zh_CN.GB18030″
LANGUAGE=”zh_CN.GB18030:zh_CN.GB2312:zh_CN”
SUPPORTED=”zh_CN.GB18030:zh_CN:zh:en_US.UTF-8:en_US:en”
SYSFONT=”lat0-sun16″

这样中文在SSH,telnet终端就可以正常显示了。

2.安安装Linux的时候选择的是中文字,但是使用的时候出现了乱码解决方法是在命令提示下输入export LANG=C

3.export LC_ALL=zh_CN.GBK
export LANG=zh_CN.GBK

April 28, 2003

History

The history of computer operating systems starts in the 1950s, with simple schemes for running batch programs efficiently, minimizing idle time between programs. A batch program is one that does not interact with the user at all. It reads all its input from a file (possibly a stack of punch cards) and outputs all its output to another file (possibly to a printer). This is how all computers used to work.

Then, in early 1960s, interactive use started to gain ground. Not only interactive use, but having several people use the same computer at the same time, from different terminals. Such systems were called time-sharing systems and were quite a challenge to implement compared to the batch systems.

During the 1960s there were many attempts at building good time-sharing systems. Some of these were university research projects, others were commercial ones. One such project was Multics, which was quite innovative at the time. It had, for example, a hierarchical file system, something taken for granted in modern operating systems.

The Multics project did not, however, progress very well. It took years longer to complete than anticipated and never got a significant share of the operating system market. One of the participants, Bell Labs, withdrew from the project. The Bell Labs people who were involved then made their own operating system and called it Unix.

Unix was originally distributed for free and gained much popularity in universities. Later, it got an implementation of the TCP/IP protocol stack and was adopted as the operating system of choice for early workstations.

By 1990, Unix had a strong position in the server market and was especially strong in universities. Most universities had Unix systems and computer science students were exposed to them. Many of them wanted to run Unix on their own computers as well. Unfortunately, by that time, Unix had become commercial and rather expensive. About the only cheap option was Minix, a limited Unix-like system written by Andrew Tanenbaum for teaching purposes. There was also 386BSD, a precursor NetBSD, FreeBSD, and OpenBSD, but that wasn’t mature yet, and required higher end hardware than many had at home.

Into this scene came Linux, in October, 1991. Linus Torvalds, the author, had used Unix at the University of Helsinki, and wanted something similar on his PC at home. Since the commercial alternatives were way too expensive, he started out with Minix, but wanted something better and soon started to write his own operating system. After its first release, it soon attracted the attention of several other hackers. While Linux initially was not really useful except as a toy, it soon gathered enough features to be interesting even for people uninterested in operating system development.

Linux itself is only the kernel of an operating system. The kernel is the part that makes all other programs run. It implements multitasking, and manages hardware devices, and generally enables applications to do their thing. All the programs that the user (or system administrator) actually interacts with are run on top of the kernel. Some of these are essential: for example, a command line interpreter (or shell), which is used both interactively and to write shell scripts (corresponding to .BAT files).

Linus did not write these programs himself, and used existing free versions instead. This reduced greatly the amount of work he had to do to get a working environment. In fact, he often changed the kernel to make it easier to get the existing programs to run on Linux, instead of the other way around.

Most of the critically important system software, including the C compiler, came from the Free Software Foundation’s GNU project. Started in 1984, the GNU project aims to develop an entire Unix-like operating system that is completely free. To credit them, many people like to refer to a Linux system as a GNU/Linux system. (GNU has their own kernel as well.)

During 1992 and 1993, the Linux kernel gathered all the necessary features it required to work as a replacement for Unix workstations, including TCP/IP networking and a graphical windowing system (the X Window System). Linux also received plenty of industry attention, and several small companies were started to develop and distribute Linux. Dozens of user groups were founded, and the Linux Journal magazine started to appear in early 1994.

Version 1.0 of the Linux kernel was released in March, 1994. Since then, the kernel has gone through many development cycles, each culminating in a stable version. Each development cycle has taken a year or three, and has involved redesigning and rewriting large parts of the kernel to deal with changes in hardware (for example, new ways to connect peripherals, such as USB) and to meet increased speed requirements as people apply Linux to larger and larger systems (or smaller and smaller ones: embedded Linux is becoming a hot topic).

From a marketing and political point of view, after the 1.0 release the next huge step happened in 1997, when Netscape decided to release their web browser as free software (the term ‘open source’ was created for this). This was the occasion that first brought free software to the attention of the whole computing world for the time. It has taken years of work since then, but free software (whether called that or open source) has become not only generally accepted but also often the preferred choice for many applications.

Social phenomenon

Apart from being a technological feat, Linux is also an interesting social phenomenon. Much through Linux, the free software movement has broken through to general attention. On the way, it even got an informal marketing department and brand: open source. It is baffling to many outsiders that something as successful as Linux could be developed by a bunch of unorganized people in their free time.

The major factor here is the availability of all the source code to the system, plus a copyright license that allows modifications to be made and distributed. When the system has many programmers among its users, if they find a problem, they can fairly easily fix it. Additionally, if they think a feature is missing, they can add it themselves. For some reason, that is something programmers like to do, even if they’re not paid for it: they have an itch (a need), so they scratch (write the code to fill the need).

It is necessary to have at least one committed developer who puts in lots of effort. After a while, however, once there are enough programmer-users sending small changes and improvements, you get a snowball effect: lots of small changes result in a fairly rapid total development speed, which then attracts more users, some of which will be programmers. This then results in more small changes and improvements sent in by users, and so on.

For operating system development specifically, this large group of programmer-users results in two important types of improvements: bug fixes and device drivers. Operating system code often has bugs that only occur rarely and it can be difficult for the developers to reproduce them. When there are thousands or more users who are also programmers, this results in a very effective testing and debugging army.

Most of the code volume in Linux is device drivers. The core functionality, which implements multitasking and multiuser functionality, is small in comparison. Most device drivers are independent from each other, and only interact with the operating system core via well defined interfaces. Thus, it is fairly easy to write a new device driver without having to understand the whole complexity of the operating system. This also allows the main developers to concentrate on the core functiionality, and they can let those people write the device drivers who actually have the devices.

It would be awkward just to store the thousands of different sound cards, Ethernet cards, IDE controllers, motherboards, digital cameras, printers, and so on that Linux supports. The Linux development model is distributed, and spreads the work around quite effectively.

The Linux model is not without problems. When a new device gets on the market, it can take a few months before a Linux programmer is interested enough to write a device driver. Also, some device manufacturers, for whatever reason, do not want to release programming information for their devices, which can prevent a Linux device driver to be written at all. Luckily, with the growing global interest in Linux such companies become fewer in numbers.

What it is

Linux is a Unix-like multitasking, multiuser 32 and 64 bit operating system for a variety of hardware platforms and licensed under an open source license. This is a somewhat accurate but rather brief description. I’ll spend the rest of this article expounding on it.

Being Unix-like means emulating the Unix operating system interfaces so that programs written for Unix will work for Linux merely by re-compiling. It follows that Linux uses mostly the same abstractions as the Unix system. For example, the way processes are created and controlled is the same in Unix and Linux.

There are a number of other operating systems in active use: from Microsoft’s family of Windows versions, through Apple’s MacOS to OpenVMS. Linux’s creator, Linus Torvalds, chose Unix as the model for Linux partly for its aesthetic appeal to system programmers, partly because of all the operating systems he was familiar with, it was the one he knew best.

The Unix heritage also gives Linux the two most important features: multitasking and multiuser capabilities. Linux, like Unix, was designed from the start to run multiple processes independently of each other. Implementing multitasking well requires attention at every level of the operating system. It is hard to add multitasking to an operationg system afterwards. That’s why the Windows 95 series and MacOS (before MacOS X) did multitasking somewhat poorly: multitasking was added to an existing operating system, not designed into a new one. That’s also why the Windows NT series, MacOS X, and Linux do multitasking so much better.

A good implementation of multitasking requires, among other things, proper memory management. The operating system must use the memory protection support in the processor to protect running programs from each other. Otherwise a buggy program (that is, most any program) may corrupt the memory area of another program, or the operating system itself, causing weird behavior or a total system crash, with likely loss of data and unsaved work.

Supporting many concurrent users is easy after multitasking works. You label each instance of a running program with a particular user and prevent the program from tampering with other user’s files.

Portable and scalable

Linux was originally written for an Intel 386 processor, and naturally works on all successive processors. After about three years of development, work began to adapt (or port) Linux to other processor families as well. The first one was the Alpha processor, then developed and sold by the Digital Equipment Corporation. The Alpha was chosen because Digital graciously donated a system to Linus. Soon other porting efforts followed. Today, Linux also runs on Sun SPARC and UltraSPARC, Motorola 68000, PowerPC, PowerPC64, ARM, Hitachi SuperH, IBM S/390, MIPS, HP PA-RISC, Intel IA-64, DEC VAX, AMD x86-64 and CRIS processors. (See http://kernel.org for details.)

Most of those processors are not very common on people’s desks. For example, S/390 is IBM’s big mainframe architecture. Here, mainframe means the kind of computer inside of which you can put your desk, rather than the kind that fits on your desk.

Some of those processors are 32 bit, like the Intel 386. Others are 64 bit, such as the Alpha. Supporting such different processors has been good for Linux. It has required designing the system to use proper modularity and good abstractions and this has improved code quality.

The large variety of supported processors also shows off Linux’s scalability: it works everything from very small systems, such as embedded computers, handheld devices, and mobile phones, to very large systems, such as the IBM mainframes.

Using clustering technology, such as Beowulf (http://www.beowulf.org/), Linux even runs on supercomputers. For example, the US Lawrence Livermore National Laboratories bought a cluster with 1920 processors, resulting in one of the five fastest supercomputers in the world with a theoretical peak performance of 9.2 teraFLOPS or 9.2 trillion calculations per second. (http://lwn.net/Articles/4759/).

Using Linux

The operating system itself is pretty boring to most people. Applications are necessary so to get things done. Traditionally, Linux applications have been the kinds of applications used with Unix: scientific software, databases, and network services. Also, of course, all the tools programmers want for their craft.

Much of such software seems rather old-fashioned by today’s desktop standards. User interfaces are text based, or they might not exist at all. Indeed, most software has usually been non-interactive and has been of the command line, batch processing variety. Since most users have been experts in the application domain, this has been good enough.

Thus, Linux first found corporate employment as a file server, mail server, web server, or firewall. It was a good platform for running a database, with support from all major commercial database manufacturers.

In the past few years Linux has also become an interesting option on the user friendly desktop front. The KDE (http://www.kde.org/) and Gnome (http://www.gnome.org/) projects develop desktop environments and applications that are easy to learn (as well as effective to use). There is now plenty of desktop applications which people with Windows or MacOS experience will have no difficulty using.

There is even a professional grade office software package. OpenOffice (http://www.openoffice.org/), based on Sun’s StarOffice, is free, fully featured, and file compatible with Microsoft Office. It includes a word processor, spreadsheet, and presentation program, competing with Microsoft’s Word, Excel, and Powerpoint.

Linux distributions

To install Linux, you have to choose a Linux distribution. A distribution is the Linux kernel, plus an installation program, plus some set of applications to run on top of it. There are hundreds of Linux distributions, serving different needs.

All distributions use pretty much the same actual software, but they are different in which software they include, which versions they pick (a stable version known to work well or the latest version with all the bells and whistles and bugs), how the software is pre-configured, and how the system is installed and managed. For example, OpenOffice, Mozilla (web browser), KDE and Gnome (desktop environments), and Apache (web server) will all work on all distributions.

Some distributions aim to be general purpose, but most of them are task specific: they are meant for running a firewall, a web kiosk, or meant for users within a particular university or country. Those looking for their first Linux experience can concentrate on the three biggest general purpose distributions: Red Hat, SuSE, and Debian.

The Red Hat and SuSE distributions are produced by companies by the same names. They aim at providing an easy installation procedure, and for a pleasant desktop experience. They are also good as servers. Both are sold in boxes, with an installation CD and printed manual. Both can also be downloaded via the network.

The Debian distribution is produced by a volunteer organization. It’s installation is less easy: you have to answer questions during the installation the other distributions deduce automatically. Nothing complicated as such, but requiring understanding of and information about hardware most PC users don’t want to worry about. On the other hand, after installation, Debian can be upgraded to each new release without re-installing anything.

The easiest way to try out Linux is to use a distribution that works completely off a CD-ROM. This way, you don’t have to install anything. You merely download the CD-ROM image from the net and burn it on a disk, or buy a mass-produced one via the net. Insert disk in drive, then reboot. Not having to install anything on the hard disk means you can easily switch between Linux and Windows. Also, since all Linux files are on a read-only CD-ROM, you can’t break anthing by mistake while you’re learning.

Further information

• The Linux Documentation Project. A good place to start looking for manuals and help.
• Linux Weekly News, Slashdot: Two important news sites about Linux and related things.
• Linux distributions: http://www.debian.org/, http://www.redhat.com/, http://www.suse.com/us/index.html.
• Knoppix: Single bootable CD, for testing Linux without installing.

Author blurb

Lars Wirzenius designs and implements embedded telematic software for Oliotalo at work, and develops Debian at home.