下载:Get Linux 0.1

via:http://www.cnbeta.com/articles/168282.htm

　　自从发行深度Linux操作系统，深度一直贯彻“免除新手痛苦、节约老手时间”这个口号，力图为用户打造顺畅、舒服的桌面操作系统系统。如今，他们正朝着这个方面不断努力。

 

Linux Deepin 11.12桌面

据了解，当年深得国内网友喜爱的Windows XP三大定制版深度、番茄花园、雨林木风，经过2008年底的反盗版风暴而纷纷相继关门。番茄花园自此烟消云散，雨林木风凭借着高仿Windows XP版的Ylmf OS重新踏上了桌面操作系统的行列，目前已经发布了Ylmf OS 4.0，而深度则通过Linux Deepin活动网友的追捧，目前也已经发布到了Linux Deepin 11.12。

今天重点介绍Linux Deepin，这是一款基于国外比较知名的Ubuntu桌面操作系统的衍生版，支持网址linux.deepin.org，其前身为2004年由hiweed发起的hiweed linux项目，这也是国内第一个中文社区发布版。

2009年底，Hiweed Linux并入深度技术社区，更名为Linux Deepin项目。经过开发团队的努力，Linux Deepin获得了广泛的关注和认同，仅主站点的下载量就达到了数十万。 在目前全球Linux发布版Top 100排名中，这在当时是唯一一个由中国人制作并上榜的Linux发行版。

2011年5月28日，Linux Deepin开源社区在武汉召开了 “Linux Deepin 2011开发者和用户大会”。这也是国内首次由开源社区组织的特定Linux发布版用户线下会议。在本次会议中，Linux Deepin团队也宣布未来3年linuxDeepin系统的发展路线，并发布Deepin Linux软件中心测试版本。

另外，2011年，Linux Deepin获得了进一步的投资和赞助，并在武汉建立了专职研发团队，从事linux桌面与系统平台相关的研发工作；并且和武汉相关高校建立了联系，筹备建立联合linux系统研发实验室。该实验室的成立，将进一步提高Linux Deepin的开发和技术支持能力。

简述Deepin Linux安装过程

深度Linux一直是国人非常喜爱的Linux操作系统之一，主要原因还是它得到了国内开发者的大力支持，在很多地方将汉化工作做得很到位。现在，先从深度Linux的安装过程开始了解起吧。

 

安装类型

 

键盘布局设置

注册登录用户和密码

安装过程

新桌面

深度软件中心

截图工具

发行说明：http://news.opensuse.org/2012/01/01/opensuse-edu-li-f-e-12-1-out-now/

下载地址：openSUSE-Edu-li-f-e-12.1-1-i686.iso (2,929MB, MD5, torrent).

注意点：

1.status表明了进程终止时的状态。当子进程使用_exit()后，父进程如果在用wait()等待子进程，那么wait()将会返回status状态，注意只有status的低8位(0~255)会返回给父进程。通常，我们使用0，表示进程成功返回，非负值表示进程不成功返回。但是，这种约定不是强制的，每个应用程序都可以自己指定。

2.虽然返回值可以是0~255，但是我们通常使用0~128。因为在shell编程中，如果一个进程被信号打断，shell会返回128+信号编号。在shell中，这两个值是没有区别的(都是当做进程返回值)，如果我们进程中使用了128~255，那么就无法区别到底是信号打断还是进程自己退出了。

void exit(int status)

注意点：

1.在exit()调用后，退出处理函数(exit handler)首先被执行(这些函数使用atexit()和on_exit()注册)。

2.stdio流缓冲区被刷新。(还有其他资源的清理)

3.最后一步才是调用_exit()退出。

4.在main函数中最后调用return n和调用exit()是相同的作用。如果在main函数最后调用return或不调用任何退出函数，调用main的运行时函数会自动的调用exit()，但是status会变得不确定(在C89中，status可能会是栈中的某个值，或CPU寄存器中的某个值，这要看编译器是怎么使用的。在C99中，要求status必须是0)。

注册退出处理函数

在程序退出之前，我们都会主动地做一些清理的动作，比如把程序缓冲区的数据保存在文件上。通常的做法是在exit()之前，调用一些清理函数。但这种做法的弊端是，在每个可能退出的地方都写上一大堆相同的代码。另外一种方式就是让程序中所有可能退出的点，都全部集中在一个地方处理。这样做的问题是会出现大量的判断是否成功语句，让代码显得不清晰。Linux提供了下面的两个函数来解决这种问题，把所有的清理函数注册进lib库中，当任意一处调用exit()时，系统会自动的调用注册上的清理函数。

int atexit(void (*func)(void))

注意点：

1.可以注册多个函数，并且一个函数也可多次注册。当要调用它们时，是按照FILO顺序执行的。

2.函数注册后，没办法取消注册。

3.清理函数中调用exit()的行为，在SUSv3中没有定义。在linux中，会继续执行剩下的清理函数。但在某些系统中，可能出现死循环。

4.子进程会继承父进程中的清理函数。

#define _BSD_SOURCE

int on_exit(void (*func)(int, void *)， void *arg)

注意点：

1. on_exit()是atexit()的改良版。在on_exit()中，可以通过func中的int参数知道exit()的退出状态;同一个func可以根据arg的不同，执行不同的代码。

2.唯一的缺点是并不是每个系统都实行了改函数。

代码分析

int main(int argc, char *argv[])

{

printf(“Hello world\n”);

Write(STDOUT_FILENO, “CC\n”， 3);

if (fork() == -1)

exit(1);

exit(0);

}

当在终端执行该程序时，输出入下：

Hello World

CC

当把文字输出到文件时，文件中保存的文字如下：

CC

Hello World

Hello World

分析：当把文字输出到终端时，stdio函数组是按行输出。而输出到文件时，是按照块输出。也就是说，在输出到文件时，printf()函数把”Hello World\n”输入进用户stdio缓冲区，但是没有达到输出块的大小。write函数直接把“CC\n”输出到内核缓冲区，而不是用户进程的缓冲区。接下来fork()出一个子进程，子进程的用户缓冲区是拷贝父进程的，也就是说在子进程中的stdio缓冲区中也存在一个”Hello World\n”，但是内核缓冲区是不会拷贝的。CC出现在Hello World前面是因为执行完write()后，CC已近在内核缓冲区中，而printf()后“Hello World”还在用户stdio缓冲区中，直到执行了exit()，才把“Hello World”刷新到内核缓冲区中。

来源:中国IT实验室  佚名

确定可能的硬件挑战

在考虑迁移的过程中，最应该注意的问题就是平台依赖性，特别是从RISC迁移到X86平台。这时候，Endianess就能派上用场。

Endianess是指用于显示数据的内存排序。它规定数据元素和字节如何在内存中存储。您可能会遇到的问题就是在x86的计算机系统中很少使用Endian,但是RISC系统中却大量的使用Endian.如果您从RISC迁移到x86,反之亦然，您将需要修改迁移代码。在评估阶段，您就应该清楚的意识到这些问题。

一些厂商已经想出了一些颇有创意的办法去解决这些问题。例如： IBM开发了PowerVM Lx86,这是一个中型规模的虚拟化引擎的部件。它使用特别的软件自动把指令转换成电压信号，从而不用在本机上进行编译。

虽然在Linux运行在IBM Power平台之前，Linux必须在本地运行并重新编译。当然，这个已经不再是个问题。转换器作为PowerVM Lx86的一部分，能把x86 Linux指令很轻松地转换成电压 Linux指令，只需三步：解码、优化和生产代码。这非常适用于Web应用程序，因为有大量重复工作，因为这些频繁使用的代码已经在内存中，所以无需再重新转换。

另一个需要考虑的方面是应用程序需要的内核扩展和设备驱动。为应用程序找到合适的内核扩展和设备驱动并不是一件容易的事情，其中部分原因是大多数的内核API并不严格遵从标准。API指令、参数的数量和调用到内核扩展的过程在新平台上都会有所不同。

另一个要考虑的是需要内核扩展和设备驱动程序的应用程序。这些都不是容易的候选支持，这一部分是因为大多数的内核API不遵循任何严格的标准。 API调用的参数的数量和加载到内核扩展的过程中将所有的功能不同的新的平台上。

评估应用程序对于Linux的适用性和有效性

绝大多数的商业和网络应用程序都能在Linux上运行。但是有效性则是另一回事。

虽然今天几乎所有的生产商都已经把他们的Unix应用程序移到Linux上，但是关键是，在考虑迁移之前，如何确保现有的应用程序已经能很好地支持了这种可能的迁移。否则，您将不得不陷入自己去迁移这些应用程序的困境。对于内部应用程序的开发，您需要的是一个强大的开发团队来帮助完成应用程序的迁移。

向有过此种经验的同事咨询。了解一下您的应用程序迁移到Linux会如何。并且核实这些应用程序现在的运行情况。不用担心，请大胆地向您的生产商请求帮助。Red Hat和SUSE都提供相应的服务帮助您完成移植。

关于部署的问题和错误

当你在做迁移的时候，你可能会遇到什么样的错误或问题?首先，适当的测试非常必要。在迁移过程中，任何一件事情都可能出错，所以在生成环境之前，应该搭建一个测试和实验环境来发现和经历问题。

几年前，我的小组看似非常顺利地完成了一个重要的迁移，但是不久就开始接到电话说工资管理系统不能正常运行。这有点出乎我们的意料，之前我们进行了系统的单元测试、用户测试以及UAT测试。事实证明，问题不是出在迁移方面，而是因为一些PC客户端不能很好的与旧版本的Oracle客户端兼容。

还有一个问题是有关Unix外壳脚本。有人可能想当然的认为，Unix外壳脚本在Linux平台上也一样能很好地运行。不幸的是，这种假设不成立。

任何一个与应用程序有关的Unix脚本都需要仔细测试。Linux的标准外壳是使用Bash外壳，它是建立在Unix最初的Bourne外壳。然而，在我们的例子里，Unix使用的是Korn外壳。所以，肯定有些功能不能正确工作。因此，有必要假设您的外壳脚本在新平台下可能不能正常工作。请测试每一个您需要的外壳脚本。

获取技术支持

技术支持取决于您IT部门的大小和员工的经验。您是否有几个无所不能、经验丰富的Linux管理员呢?或者他们也许是Unix管理员，但是他们是否已经做好准备去接受Linux呢?

技术支持程度取决于您所用于的环境类型。您是否正在运行那些每分钟的故障能导致公司数万美元损失的系统呢 ,如：CRM系统或者工资系统?

来自于生产商的技术支持也是非常重要。Red Hat和Novell都提供24/7的技术支持。一些Unix硬件生产商，如IBM,也提供自己的Linux技术支持。

如果可能，请从您的硬件提供商那里获得技术支持。而且，这对您从操作系统提供商哪里获得技术支持不会产生任何不利的影响。最后还是那句话，您需要仔细考虑您的组织中，系统停机带来的经济影响和您员工的经验和能力。

来源:TechTarget中国

Linux内核维护者Greg Kroah-Hartman于2010年春季把Android驱动移除出了Linux 2.6.33之后，曾一度传言可能近4-5年内都不会再回到Linux内核之中。

发行说明：
http://forum.tinycorelinux.net/index.php/topic,12191.0.html

下载地址：
TinyCore-4.2.iso (11.9MB, MD5)
CorePlus-4.2.iso (48.0MB, MD5).

via:http://www.lupaworld.com/article-215238-1.html

MySemaphore.h

view plain

#ifndef Semaphore_Header

#define Semaphore_Header

#include

#include

#include

#include

using namespace std;

//————————————————————————

class CSemaphoreImpl

{

protected:

CSemaphoreImpl(int n, int max);

~CSemaphoreImpl();

void SetImpl();

void WaitImpl();

bool WaitImpl(long lMilliseconds);

private:

volatile int m_n;

int m_max;

pthread_mutex_t m_mutex;

pthread_cond_t m_cond;

};

inline void CSemaphoreImpl::SetImpl()

{

if (pthread_mutex_lock(&m_mutex))

cout<<”cannot signal semaphore (lock)”<

if (m_n < m_max)

{

++m_n;

}

else

{

pthread_mutex_unlock(&m_mutex);

cout<<”cannot signal semaphore: count would exceed maximum”<<” m_n = “<

}

pthread_mutex_unlock(&m_mutex);

}

//————————————————————————

/*

信号量同步机制

信号量提供一个计数值，可以进行原子操作。V 将计数值加1，使得

等待该信号量的线程可以被调用(调用Set())，P 将计数值减1，使

当前线程被挂起，进行睡眠(调用Wait())。

当信号量的计数值被初始化为0时，调用P操作，将挂起当前线程。

当信号量被激活，即调用V操作后，被挂起的线程就有机会被重新调度了。

*/

class CMySemaphore: private CSemaphoreImpl

{

public:

/*

创建一个信号量，信号量计数值当前值为参数n，最大值为max。

如果只有n，则n必须大于0;如果同时有n和max,则n必须不小

于0，且不大于max

*/

CMySemaphore(int n);

CMySemaphore(int n, int max);

/*

销毁一个信号量

*/

~CMySemaphore();

/*

对信号量计数值做加1动作，信号量变为有信号状态，使得

另一个等待该信号量的线程可以被调度

*/

void Set();

/*

对信号量计数值做减1动作，信号量变为无信号状态。若

计数值变得大于0时，信号量才会变为有信号状态。

*/

void Wait();

/*

在给定的时间间隔里等待信号量变为有信号状态，若成功，

则将计数值减1，否则将发生超时。

*/

void Wait(long lMilliseconds);

/*

在给定的时间间隔里等待信号量变为有信号状态，若成功，

则将计数值减1，返回true;否则返回false。

*/

bool TryWait(long lMilliseconds);

private:

CMySemaphore();

CMySemaphore(const CMySemaphore&);

CMySemaphore& operator = (const CMySemaphore&);

};

inline void CMySemaphore::Set()

{

SetImpl();

}

inline void CMySemaphore::Wait()

{

WaitImpl();

}

inline void CMySemaphore::Wait(long lMilliseconds)

{

if (!WaitImpl(lMilliseconds))

cout<<”time out”<

}

inline bool CMySemaphore::TryWait(long lMilliseconds)

{

return WaitImpl(lMilliseconds);

}

#endif

MySemaphore.cpp

view plain

#include “MySemaphore.h”

#include

CSemaphoreImpl::CSemaphoreImpl(int n, int max): m_n(n), m_max(max)

{

assert (n >= 0 && max > 0 && n <= max);

if (pthread_mutex_init(&m_mutex, NULL))

cout<<”cannot create semaphore (mutex)”<

if (pthread_cond_init(&m_cond, NULL))

cout<<”cannot create semaphore (condition)”<

}

CSemaphoreImpl::~CSemaphoreImpl()

{

pthread_cond_destroy(&m_cond);

pthread_mutex_destroy(&m_mutex);

}

void CSemaphoreImpl::WaitImpl()

{

if (pthread_mutex_lock(&m_mutex))

cout<<”wait for semaphore failed (lock)”<

while (m_n < 1)

{

//对互斥体进行原子的解锁工作,然后等待状态信号

if (pthread_cond_wait(&m_cond, &m_mutex))

{

pthread_mutex_unlock(&m_mutex);

cout<<”wait for semaphore failed”<

}

}

–m_n;

pthread_mutex_unlock(&m_mutex);

}

bool CSemaphoreImpl::WaitImpl(long lMilliseconds)

{

int rc = 0;

struct timespec abstime;

struct timeval tv;

gettimeofday(&tv, NULL);

abstime.tv_sec = tv.tv_sec + lMilliseconds / 1000;

abstime.tv_nsec = tv.tv_usec*1000 + (lMilliseconds % 1000)*1000000;

if (abstime.tv_nsec >= 1000000000)

{

abstime.tv_nsec -= 1000000000;

abstime.tv_sec++;

}

if (pthread_mutex_lock(&m_mutex) != 0)

cout<<”wait for semaphore failed (lock)”<

while (m_n < 1)

{

//自动释放互斥体并且等待m_cond状态,并且限制了最大的等待时间

if ((rc = pthread_cond_timedwait(&m_cond, &m_mutex, &abstime)))

{

if (rc == ETIMEDOUT) break;

pthread_mutex_unlock(&m_mutex);

cout<<”cannot wait for semaphore”<

}

}

if (rc == 0) –m_n;

pthread_mutex_unlock(&m_mutex);

return rc == 0;

}

CMySemaphore::CMySemaphore(int n): CSemaphoreImpl(n, n)

{

}

CMySemaphore::CMySemaphore(int n, int max): CSemaphoreImpl(n, max)

{

}

CMySemaphore::~CMySemaphore()

{

}

下边是测试代码

view plain

// pthread_semaphore.cpp : 定义控制台应用程序的入口点。

//

#include “MySemaphore.h”

//创建一个信号量，其计数值当前值为0，最大值为3

CMySemaphore g_MySem(0, 3);

//线程函数

void * StartThread(void *pParam)

{

//休眠1秒，确保主线程函数main中

//创建工作线程下一句g_MySem.Set();先执行

sleep(1);

g_MySem.Wait(); //信号量计数值减1

cout<<”Do print StartThread”<

return (void *)0;

}

int main(int argc, char* argv[])

{

pthread_t thread;

pthread_attr_t attr;

assert ( !g_MySem.TryWait(10) );

g_MySem.Set(); //信号量计数值加1

g_MySem.Wait(); //信号量计数值减1

try

{

g_MySem.Wait(100);

cout<<”must timeout”<

}

catch (…)

{

cout<<”wrong exception”<

}

g_MySem.Set();

g_MySem.Set();

assert ( g_MySem.TryWait(0) );

g_MySem.Wait();

assert ( !g_MySem.TryWait(10) );

//创建工作线程

pthread_attr_init(&attr);

pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_JOINABLE);

if (pthread_create(&thread,&attr, StartThread,NULL) == -1)

{

cout<<”StartThread: create failed”<

}

g_MySem.Set();

//等待线程结束

void *result;

pthread_join(thread,&result);

assert ( !g_MySem.TryWait(10) ); //若将断言中的 ! 去掉，则会发生断言错误

//关闭线程句柄，释放资源

pthread_attr_destroy(&attr);

int iWait;

cin>>iWait;

return 0;

}

编译，运行。可以看到，与Win32平台上的测试结果相同

由此可见，信号量机制很关键的一点就是计数值 m_n。