straceandroid

⑴ windows，linux，unix系统有什么区别为什么说黑客偏爱linux

2003年6月，一些计算机黑客举行了一次“篡改者挑战赛”，目标是在6小时内篡改6000个网站的页面。根据所攻破的操作系统的不同为参与者计分。采用Windows系统的网站计1分，UNIX或Linux，3分。也就是说，他们认为UNIX和linux比较难以攻破。

一、 理解误区：
误区一：linux比windows更容易被攻击
有人任务Linux的代码完全开放，也就是说，何人都能得到UNIX和Linux中的“透明代码”——包括黑客、心怀不满的员工和竞争对手——而Windows的代码是收到严格保护的知识产权，那么UNIX和Linux就应该比Windows更容易受到攻击了，对吧？

“不对，”Justin Steinman，Novell北美区经理说，“和Windows所谓‘以隐匿求安全’相比，Linux的‘以透明求安全’更为安全。因为整个Linux团体都在完善和关注其代码。一旦有人发现安全漏洞，人们就会对它进行修补，并把补丁程序发布给整个团队。”

Steinman把这种响应速度和微软的“补丁星期二”做了对比。微软每个月的的第二个星期二发布Windows操作系统和其他应用软件的补丁程序。“如果你在第二个星期三发现了漏洞呢？你得等上30天才能得到补丁程序。”他说。
误区二：大多数Windows能干的事Linux干不了
像我们日常用的一些QQ,暴风影音，Word在Linux上都能使用，相对一些更加专业话的软件Linux更是一个先驱者，比如 Matlab, Mathematica, AutoCAD, Candence的，Synopsys的，Avant!的......全都是先有 UNIX的版本(包括Linux)，然后再考虑移植给Windows，甚至根本不移植给 Windows，因为 Windows的机器一般没有足够的能力运行这样的程序。
误区三：IDE
有些人在抱怨为什么 Linux没有一个良好的 IDE开发环境。Linux现在已经有一些 IDE了，但是总是有很多问题。你是不是正在寻找，正在期望 Linux某一天可以有一个VC那样的开发环境？你有没有发现你正在进入微软给你设下的怪圈？你为什么一定要用 IDE？你说："IDE开发迅速，调试方便，适合大型程序......"那说明微软的程序在我们的脑子里已经比较根深蒂固，真的是时候需要好好清醒一下了。
看看大型的 UNIX程序，包括 Linux内核，各种网络服务程序，Xwindow程序在内，哪一个是 IDE搞出来的？还有Candence, Synopsys，Mentor的高性能的图形界面 EDA程序也都不是 IDE写的。微软的人在写 Windows本身的时候也根本不用 IDE！
有的时候，我们甚至将"编辑器"和"编译器"都搞混淆了！一个窗口里输入了代码，点击一个按钮就可以编译程序，但是这里面到底是怎么工作的，不知道！我们被盖在上面的窗口挡住了视线，甚至会以为那个按钮就是编译器！一个 IDE 集成了编辑器，编译器，汇编器，调试器，跟踪器......这个编辑器功能肯定比不上 VIM或 Emacs，编译器比不上 GCC，汇编器比不上 as，调试器比不上 gdb, ddd,跟踪器比不上 strace, ltrace, truss。最后我们得到的是一套整合的很好的低能的程序。
而在 UNIX下就不一样了。你可以用你最喜欢的 VIM编辑程序，你在 VIM里可以调用 GNU make，make可以调用 gcc, ld, ...实际上 make能帮你很多忙。make的出错信息可以被 VIM捕获，VIM能帮你在源程序里定位。你如果喜欢 icc,你可以让 make用 icc而不是 gcc。你如果觉得 gdb跟踪变量时比较麻烦，你可以用 ddd来显示各种数据结构之间的关系。你还可以在 Emacs里调用 gdb，那样就可以同步显示源代码了。而且 VIM和 Emacs还可以编辑很多其它东西，比如信件，LaTeX文档，HTML，配置文件......你不用另外找一个什么编辑器来干这些杂活了。很多程序比如 Mutt, tin都可以在内部使用 VIM，这样就更方便了。

二、安全性方面
1权限方面：
Quandt指出，Linux和UNIX在架构中采用了“最少特权”概念。她把提供某些门的专用钥匙与提供能打开所有房门的万能钥匙做了比较。在Linux 2.6中，安全架构比以前的版本有了很大改善，支持最少特权，具有以角色为基础的接近权控制，用户只进入他们需要使用的那部分系统即可。
2 用户结构方面：
多用户设计假定用户较多，但坦白讲，对他们信任较少。简单来说，Windows把用户程序和操作系统的核心集成到一起，而Linux和UNIX则把核心区域与用户区域区分开来。
“这是固有的安全。” Sun公司Solaris Security经理Mark Thacker说，“UNIX从最开始就是多用户系统，不是逐渐演变为服务器操作系统的台式机系统。UNIX一直都是把用户领域和核心领域分开的，这是任何源于DOS的操作系统所不具备的。”
3运行状况方面：
可以裸奔（无需杀毒软件，反广告／间谍防护软件），甚至可以数月不用重启机器，因为它具有独特的内存管理方式。（大家可以想一下如果windows下裸奔会是怎样的后果；windows如果很长一段时间不关机或是重启，那么它运行肯定不会有刚开机时那么流畅），所以说安全上Linux与windows比较没意思。

二、 技术特点分析
这一方面就更加没有意思了，甚至可以夸张的一点描述UNIX/Linux可以将Windows秒出十万八千里。
1 内存机制方面
Linux有比 Windows先进的磁盘缓冲技术。你有没有发现你往硬盘写数据的时候，很快就完成了？那是因为 Linux在内存里有很多磁盘缓冲区，你要写到硬盘上的数据先被写到了这些内存里。在一定的间隔时间后，Linux才把数据写回硬盘，这样不但高效，避免了多次硬盘操作，而且减少了文件的不连续，也就是减少了"碎片"。Windows当然也有磁盘缓冲，但是由于它内存管理的低效率，它不敢把大量内存都用来作为磁盘缓冲，因为它没有能力在用的时候随时把内存收回来。
2与硬件结合性
由于开放源代码的特点LINUX得到AMD和INTEL公司的关注。因为这两家公司都希望在64位芯片时代能够和开放源代码的操作系统系统紧密联系LINUX的发展速度急快，从它的内核就可以看出。LINUX比其他操作系统更能适应芯片技术发展。
3并行化多任务处理
Linux系统调度每一个进程平等地访问微处理器。由于CPU的处理速度非常快，其结果是，启动的应用程序看起来好像在并行运行。事实上，从处理器执行一个应用程序中的一组指令到Linux调度微处理器再次运行这个程序之间只有很短的时间延迟，用户是感觉不出来的。
经过对最重量级的数据库Oracle 9i测试，在LINUX下的运行速度比在WIN2003 SERVER要快25%。这一篇，LINUX占了上风。每次oracle发布新版数据库的时候，都是会最先发布Linux版本的，而Windows版本的至少要半年以后才发布，深入理解后认为从底层来说俩个版本简直就是2种软件，虽然提供相同的功能。
4网络信息化
Linux的组网能力非常强大，它的TCP/IP代码是最高级的。Linux提供了对于当前的TCP/IP协议的完全支持，并且包括了对下一代Internet。协议Ipv6的支持。Linux内核还包括了IP防火墙代码、IP防伪、IP服务质量控制及许多安全特性。这些特性可以和像Cisco这样的公司提供的高端路由设备的特性相媲美。此外，利用Redhat Linux提供的Samba组(并不是RedHat Linux独有)，Linux可以作为Windows客户机的打印和文件服务器，还可以用做NT的文件和打印服务器。运用Linux包含的AppleTalk模块，Linux甚至可以作为一个Macintosh客户机的文件和打印服务器。

三市场方面
1开源性方面：
杨元庆:“Windows不开源严重制约了IT产业发展”，开放源代码是大势所趋，Linux前途广阔。互联网免费的今天，开源性的事物将势必会有更强的生存能力。

2 PC市场方向
全球PC市场出现了历史上最严重的滑坡趋势下，虽然在Window8的强烈攻势下，消费者显得无动于衷，依然转向了智能手机和平板电脑。在如今android和iOS占据大半江山的背景下，windowsphone的前景愈发暗淡。显然微软在移动终端高速发展的今天，windows操作系统存在天然的弱势。

3 费用问题
很多Linux版本是不需要花钱的，恰恰相反，Windows每个版本的安装都是需要另付费用的。

⑵ Linux是干什么用的

Linux是一套免费使用和自由传播的类Unix操作系统，是一个基于POSIX和UNIX的多用户、多任务、支持多线程和多CPU的操作系统。Linux继承了Unix以网络为核心的设计思想，是一个性能稳定的多用户网络操作系统。

Linux可安装在各种计算机硬件设备中，比如手机、平板电脑、路由器、视频游戏控制台、台式计算机、大型机和超级计算机。严格来讲，Linux这个词本身只表示Linux内核，但实际上人们已经习惯了用Linux来形容整个基于Linux内核，并且使用GNU工程各种工具和数据库的操作系统。

(2)straceandroid扩展阅读：

Linux操作系统的主要特性;

1、完全免费并且开放

Linux是一款免费的操作系统，用户可以通过网络或其他途径免费获得，并可以任意修改其源代码。这是其他的操作系统所做不到的。

2、完全兼容POSIX1.0标准

这使得可以在Linux下通过相应的模拟器运行常见的DOS、Windows的程序。这为用户从Windows转到Linux奠定了基础。

3、多用户、多任务

Linux支持多用户，各个用户对于自己的文件设备有自己特殊的权利，保证了各用户之间互不影响。多任务则是现在电脑最主要的一个特点，Linux可以使多个程序同时并独立地运行。

⑶ 怎样提高android启动速度

首先看一下Android系统的启动流程：
bootloader
引导程序
kernel
内核
init
init初始化（这个大家都比较熟悉了，不要多说）
loads several daemons and services, including zygote
see /init.rc and init.<platform>.rc
zygote

这个是占用时间最多的，重点修理对象
preloads classes
装载了一千多个类，妈呀！！！
starts package manager 扫描package(下面详细介绍)
service manager
start services （启动多个服务）
从实际的测试数据来看，有两个地方时最耗时间的，一个是zygote的装载一千多个类和初始化堆栈的过程，用了20秒左右。另一个是扫描
/system/app,
/system/framework,
/data/app,
/data/app-private.
这几个目录下面的package用了大概10秒，所以我们重点能够修理的就是这两个老大的。
一、首先是调试工具的使用，可以测试哪些类和那些过程占用了多少时间，
主要工具为
stopwatch
Message loggers
grabserial
printk times
logcat
Android自带
bootchart
strace
AOSP的一部分（Eclair及以上版本）
使用例子
在init.rc中为了调试zygote

service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server改为
service zygote /system/xbin/strace -tt -o/data/boot.strace /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server

method tracer*
ftrace*
详细使用可看提供的文档和网页介绍
上面的工具如果不用详细的分析不一定都用到，也可以使用logcat就可以,在代码中加一点计算时间和一些类的调试信息也可以达到很好效果。
二、zygote 装载1千多个类
首先，我们可以添加一点调试信息，以获得具体转载情况。
diff --git a/core/java/com/Android/internal/os/ZygoteInit.java b/core/java/com/android/internal/os/ZygoteInit.java
index 404c513..f2b573c 100644
--- a/core/java/com/Android/internal/os/ZygoteInit.java
+++ b/core/java/com/Android/internal/os/ZygoteInit.java
@@ -259,6 +259,8 @@ public class ZygoteInit {
} else {
Log.i(TAG, "Preloading classes...");
long startTime = SystemClock.uptimeMillis();
+ long lastTime = SystemClock.uptimeMillis();
+ long nextTime = SystemClock.uptimeMillis();

// Drop root perms while running static initializers.
setEffectiveGroup(UNPRIVILEGED_GID);
@@ -292,12 +294,24 @@ public class ZygoteInit {
if (Config.LOGV) {
Log.v(TAG, "Preloading " + line + "...");
}
+ //if (count%5==0) {
+ // Log.v(TAG, "Preloading " + line + "...");
+ //}
+ Log.v(TAG, "Preloading " + line + "...");
Class.forName(line);
+ nextTime = SystemClock.uptimeMillis();
+ if (nextTime-lastTime >50) {
+ Log.i(TAG, "Preloading " + line + "... took " + (nextTime-lastTime) + "ms.");
+ }
+ lastTime = nextTime;
+
if (Debug.getGlobalAllocSize() > PRELOAD_GC_THRESHOLD) {
if (Config.LOGV) {
Log.v(TAG,
" GC at " + Debug.getGlobalAllocSize());
}
+ Log.i(TAG,
+ " GC at " + Debug.getGlobalAllocSize());
runtime.gcSoftReferences();
runtime.runFinalizationSync();
Debug.resetGlobalAllocSize();
上面+代表添加的代码，这样就可以很容易的得到在装载类的过程中具体装载了哪些类，耗费了多久。具体装载的类在文件platform/frameworks/base/ preloaded-classes
内容类似：
Android.R$styleable
Android.accounts.AccountMonitor
Android.accounts.AccountMonitor$AccountUpdater
Android.app.Activity
Android.app.ActivityGroup
Android.app.ActivityManager$MemoryInfo$1
Android.app.ActivityManagerNative
Android.app.ActivityManagerProxy
Android.app.ActivityThread
Android.app.ActivityThread$ActivityRecord
Android.app.ActivityThread$AppBindData
Android.app.ActivityThread$ApplicationThread
Android.app.ActivityThread$ContextCleanupInfo
Android.app.ActivityThread$GcIdler
Android.app.ActivityThread$H
Android.app.ActivityThread$Idler
而这个文件是由文件WritePreloadedClassFile.java中的WritePreloadedClassFile类自动生成
/**

* Writes /frameworks/base/preloaded-classes. Also updates

* {@link LoadedClass#preloaded} fields and writes over compiled log file.

*/
public class WritePreloadedClassFile
/**
* Preload any class that take longer to load than MIN_LOAD_TIME_MICROS us.
*/
static final int MIN_LOAD_TIME_MICROS = 1250;//这个代表了装载时间小于1250us即1.25ms的类将不予装载，也许可以改这个参数减少一下类的装载

//这里可以看到什么样的类会被装载

A:启动必须装载的类，比如系统级的类

B：刚才说的装载时间大于1.25ms的类

C：被使用一次以上或被应用装载的类
仔细看看筛选类的具体实现，可以帮助我们认识哪些类比较重要，哪些可以去掉。
筛选规则是
第一 isPreloadable，
/**Reports if the given class should be preloaded. */
public static boolean isPreloadable(LoadedClass clazz) {
return clazz.systemClass && !EXCLUDED_CLASSES.contains(clazz.name);
}
意思是指除了EXCLUDED_CLASSES包含的类之外的所有系统装载的类。
EXCLUDED_CLASSES包含
/**
* Classes which we shouldn't load from the Zygote.
*/
private static final Set<String> EXCLUDED_CLASSES
= new HashSet<String>(Arrays.asList(
// Binders
"Android.app.AlarmManager",
"Android.app.SearchManager",
"Android.os.FileObserver",
"com.Android.server.PackageManagerService$AppDirObserver",
// Threads
"Android.os.AsyncTask",
"Android.pim.ContactsAsyncHelper",
"java.lang.ProcessManager"
));
目前是跟Binders跟Threads有关的不会被预装载。

第二 clazz.medianTimeMicros() > MIN_LOAD_TIME_MICROS装载时间大于1.25ms。
第三 names.size() > 1 ，既是被processes一次以上的。
上面的都是指的system class,另外还有一些application class需要被装载
规则是fromZygote而且不是服务
proc.fromZygote() && !Policy.isService(proc.name)

fromZygote指的除了com.Android.development的zygote类
public boolean fromZygote() {
return parent != null && parent.name.equals("zygote")
&& !name.equals("com.Android.development");
}

/除了常驻内存的服务

/**
* Long running services. These are restricted in their contribution to the
* preloader because their launch time is less critical.
*/
// TODO: Generate this automatically from package manager.
private static final Set<String> SERVICES = new HashSet<String>(Arrays.asList(
"system_server",
"com.google.process.content",
"Android.process.media",
"com.Android.bluetooth",
"com.Android.calendar",
"com.Android.inputmethod.latin",
"com.Android.phone",
"com.google.Android.apps.maps.FriendService", // pre froyo
"com.google.Android.apps.maps:FriendService", // froyo
"com.google.Android.apps.maps.LocationFriendService",
"com.google.Android.deskclock",
"com.google.process.gapps",
"Android.tts"
));
好了。要转载的就是这些类了。虽然preloaded- classes是在下载源码的时候已经确定了的，也就是对我们来说WritePreloadedClassFile类是没用到的，我们可以做的就是在 preloaded-classes文件中，把不预装载的类去掉，试了把所有类去掉，启动确实很快跳过那个地方，但是启动HOME的时候就会很慢了。所以最好的方法就是只去掉那些没怎么用到的，不过要小心处理。至于该去掉哪些，还在摸索，稍后跟大家分享。有兴趣的朋友可以先把preloaded- classes这个文件里面全部清空，启动快了很多，但在启动apk的时候会慢了点。当然了，也可以把Android相关的类全部去掉，剩下java的类，试过了也是可以提高速度。
三，系统服务初始化和package 扫描

在启动系统服务的init2()时会启动应用层（Java层）的所有服务。
public static void main(String[] args) {

System.loadLibrary("Android_servers");
init1(args); //init1 初始化，完成之后会回调init2()
}

在init2()中会启动一个线程来启动所有服务
public static final void init2() {
Log.i(TAG, "Entered the Android system server!");
Thread thr = new ServerThread();
thr.setName("Android.server.ServerThread");
thr.start();
}

class ServerThread extends Thread {
。。。
public void run() {
。。。
关键服务：
ServiceManager.addService("entropy", new EntropyService());
ServiceManager.addService(Context.POWER_SERVICE, power);
context = ActivityManagerService.main(factoryTest);
ServiceManager.addService("telephony.registry", new TelephonyRegistry(context));

PackageManagerService.main(context,
factoryTest != SystemServer.FACTORY_TEST_OFF);//apk扫描的服务
ServiceManager.addService(Context.ACCOUNT_SERVICE,
new AccountManagerService(context));
ContentService.main(context,
factoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL);
battery = new BatteryService(context);
ServiceManager.addService("battery", battery);

hardware = new HardwareService(context);
ServiceManager.addService("hardware", hardware);
AlarmManagerService alarm = new AlarmManagerService(context);
ServiceManager.addService(Context.ALARM_SERVICE, alarm);
ServiceManager.addService(Context.SENSOR_SERVICE, new SensorService(context));

WindowManagerService.main(context, power,
factoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL);
ServiceManager.addService(Context.WINDOW_SERVICE, wm);

⑷ c语言如何将函数调用堆栈打印出来

可以直接用输出在函数内部调用时，把调用顺序打印出来。

一、一个由C/C++编译的程序占用的内存分为以下几个部分

1、栈区（stack）—由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。

2、堆区（heap）—一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。

3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。-程序结束后有系统释放

4、文字常量区—常量字符串就是放在这里的。程序结束后由系统释放

5、程序代码区—存放函数体的二进制代码。

二、例程：

//main.cpp
inta=0;全局初始化区
char*p1;全局未初始化区
main()
{
intb;栈
chars[]="abc";栈
char*p2;栈
char*p3="123456";123456在常量区，p3在栈上。
staticintc=0；全局（静态）初始化区
p1=(char*)malloc(10);
p2=(char*)malloc(20);
分配得来得10和20字节的区域就在堆区。
strcpy(p1,"123456");123456放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。
}

⑸ php swoole 只能运行在php-cli 环境吗

一直想写点Swoole的东西，毕竟它重新定义了php，却一直不知道怎么下手写Swoole涉及的知识点非常多，互为表里，每次想写都发现根本理不出一个头绪Swoole是一个php的扩展，它的核心目的就是解决php在实现server服务中可能遇到的一系列问题，这些问题用源生的php往往并不能很高效（执行效率）的解决，一般也不会使用php来解决，所以会有说swolle重新定义的php的说法。
其实swoole也提供了一个框架，swoole framework是基于swoole extension设计的一个框架，要用好这个框架，还是要先了解swoole extension。
扩展的英文名称是Extension，php扩展是用C语言作为开发语言，基于Zend引擎提供的API，编译成的一个动态库。
如果曾经做过类似动态库调用开发的童鞋可能会更好理解一些，例如Android中的NDK开发在php的配置文件中配置好extension的属性后，就可以引用这个动态库了。
也就是说，swoole本身是用C语言编写的，它可以让php获得一些额外的function。
然后是运行方式，swoole的许多功能都只能运行在cli模式下，而cli模式往往是很多刚接触swoole的phper遇到的第一个问题。
有时候其实只是需要转变一下思路
我们现在整理一下最常见的php代码执行方式：
安装apache、php
配置apache对那个目录进行php解析
用浏览器访问那个目录的php文件
更多的细节这里就不提了，毕竟我相信每个phper对这个都是很熟悉的。
但这里就开始出现了第一个问题，我们知道，php是一个脚本语言，脚本语言的核心特点在于不用编译，随时执行，而执行脚本的工具就是解析器，而php的解析器就是zend引擎。
严格来说，zend并不是唯一的选择，不过，zend是最官方的。另外，Zend Studio和Zend Engine不是同一个东西，本文中的Zend全部指Zend Engine。
换个角度讲，只要有解析器，写好的php脚本就是可以执行的，而zend引擎与apache之间并没有绝对的关系实际上，apahce是调用了zend对php脚本进行执行，然后将执行结果输出给了浏览器所以所谓cli模式（CommandLine，命令行模式），其实就是在命令行下直接调用zend引擎对php脚本进行解析并执行，并获得程序输出结果的php脚本执行方式。
其实php也可以作为shell脚本来使用哦，就像bash shell一样既然问题讲清楚了，在一个系统中具体怎么操作呢？
本文以CentOS 7.5作为系统环境，swoole是针对linux系统开发的，windows下并不适用。学习swoole的一个前题是懂得基本的linux系统使用。
当安装好php的时候，找到php的安装目录，如果是默认安装的话，可以试试whereis命令# 某种简单的方法
whereis php
> /usr/local/bin/php;
locate whereis find这些命令都可以试试，目的是找到php然后我们来写一个最经典的php脚本：
<?php
//vi hello_cli.php
echo 'Hello PHP Cli';
编写纯php脚本时，php标签不要封口
然后我们在shell里执行它：
/usr/local/bin/php hello_cli.php
> Hello PHP Cli
这段代码中的第一个php，是一个可执行文件，它接受一个php脚本文件作为输入参数，并解析执行这个php脚本文件（通过zend）。
没有错，第一个cli模式下的php程序就被你执行成功了！
默认情况下，php都会被安装在了$PATH的目录下，那就可以直接省略路径前缀了，下文中调用php的时候，全都省略了路径前缀。
因为swoole是pecl的项目，所以使用pecl安装是最简单的方法，强烈推荐第一次接触的童鞋先使用pecl安装，在熟悉了swoole之后，再考虑使用编译安装的方式以获取更多进阶功能。
pecl这个工具基本都会被安装在与php相同的目录下（往往也都是$PATH目录）pecl install swoole
执行以下命令查看是否安装成功：
php -m | grep swoole
> swoole
如果正确的输出了swoole，那么恭喜你，这次安装很成功另一个常见的比较麻烦的问题是，有些童鞋的电脑里安装了多个php，而安装的时候没有正确的安装到预期的php的扩展目录中，就会导致无法正常工作，解决方案就是弄清楚各个php安装目录及配置关系，选择正确的目录进行安装。
其实本文还没正式开始介绍swoole，都是在学习swoole之前的准备工作，swoole的上手门槛比一般的php应用要高的多，如果没有网络开发和操作系统方面的一些知识，学习它并不是一件容易的事情，学习曲线很陡峭。
这句话我在群里说了无数次
很多新手会诟病swoole的手册写的太模糊，其实是前置知识不足，而手册也给出了需要的前置知识列表，以下引用至官网的手册-学习swoole需要哪些知识？
多进程/多线程
了解Linux操作系统进程和线程的概念
了解Linux进程/线程切换调度的基本知识
了解进程间通信的基本知识，如管道、UnixSocket、消息队列、共享内存socket
了解SOCKET的基本操作如accept/connect、send/recv、close、listen、bind了解SOCKET的接收缓存区、发送缓存区、阻塞/非阻塞、超时等概念IO复用
了解select/poll/epoll
了解基于select/epoll实现的事件循环，Reactor模型了解可读事件、可写事件
TCP/IP网络协议
了解TCP/IP协议
了解TCP、UDP传输协议
调试工具
使用gdb调试Linux程序
使用strace跟踪进程的系统调用
使用tcpmp跟踪网络通信过程
其他Linux系统工具，如ps、lsof、top、vmstat、netstat、sar、ss等学习并理解一个新事务并不是一个容易的事情，特别对于swoole这种具备一定颠覆性的工具，要有耐心和实践。
淡定的把手册看完，遇到不理解的名词学会使用搜索引擎学习，swoole的手册其实是个大宝库，网络开发常见的问题其实里边都涉及到了。

⑹ Linux主要是干什么用的

主要是用于后端服务器操作系统

Linux是一种自由和开放源码的类UNIX操作系统。它能运行主要的Unix工具软件、应用程序和网络协议，支持32位和64位硬件。该操作系统的内核由林纳斯·托瓦兹于1991年10月5日首次发布。

Linux最初是作为支持英特尔x86架构的个人计算机的一个自由操作系统，现可运行在服务器和其他大型平台之上，如大型计算机和超级计算机。Linux也广泛应用在嵌入式系统上，如手机（Mobile Phone）、平板电脑（Tablet）、路由器（Router）、电视（TV）和电子游戏机等。

(6)straceandroid扩展阅读：

2001年1月，Linux 2.4发布，它进一步地提升了SMP系统的扩展性，同时它也集成了很多用于支持桌面系统的特性：USB，PC卡(PCMCIA)的支持，内置的即插即用，等等功能。

2003年12月，Linux 2.6版内核发布，相对于2.4版内核2.6在对系统的支持都有很大的变化。

2004年的第1月，SuSE嫁到了Novell，SCO继续顶着骂名四处强行“化缘”， Asianux， MandrakeSoft也在五年中首次宣布季度赢利。3月，SGI宣布成功实现了Linux操作系统支持256个Itanium 2处理器。

⑺ 精通android游戏开发的目录

第1章 欢迎进入android游戏世界 1
1.1 必备技能 1
1.1.1 扎实的android基础 1
1.1.2 linux和shell脚本的基本知识 3
1.2 需要哪些软件工具 3
1.3 建立环境 4
1.3.1 获得android源文件 4
1.3.2 提取本地android库 6
1.3.3 为arm处理器安装gnu工具链 8
1.3.4 编写定制编译脚本 10
1.4 建立开发环境 17
1.5 已经成功迈出第一步 22
第2章 在android中编译本地代码 23
2.1 第一个本地android应用 23
2.1.1 创建avd 23
2.1.2 创建android项目 26
2.1.3 应用体系结构 27
2.2 编译和测试共享库 38
2.2.1 缺少符号时的调试 40
2.2.2 在设备上测试动态库 41
.2.2.3 用strace调试 42
2.2.4 静态编译 43
2.3 测试本地应用 44
2.4 下一章内容 46
第3章 从头构建java游戏 47
3.1 android游戏与java me游戏 47
3.2 创建你的第一个java游戏——space blaster 48
3.2.1 了解游戏的体系结构 49
3.2.2 创建项目 50
3.2.3 创建游戏的活动类 51
3.2.4 创建游戏布局 53
3.2.5 实现游戏 58
3.2.6 处理按键和触控事件 66
3.3 在模拟器上测试 69
3.4 下一章内容 70
第4章 java游戏续篇：多边形的乐趣 71
4.1 关于本章安排 71
4.2 了解在android中绘制多边形的问题 71
4.3 了解绘制矩形的问题 73
4.4 为asteroids创建一个polygon类 75
4.5 为asteroids创建polygonsprite类 80
4.6 游戏的体系结构 84
4.7 创建项目 84
4.7.1 创建游戏布局 85
4.7.2 查看资源 86
4.7.3 了解游戏生命期 87
4.7.4 响应按键和触控事件 97
4.8 在模拟器上测试asteroids 100
4.9 下一章内容 101
第5章 opengl 3d图形与jni混合 102
5.1 移动设备的强大能力 103
5.2 在java中使用opengl 104
5.2.1 java主活动 106
5.2.2 表面视图 108
5.2.3 gl线程 110
5.2.4 立方体渲染器 113
5.2.5 cube类 116
5.3 以本地方式使用opengl 118
5.3.1 主活动 120
5.3.2 本地接口类 122
5.3.3 对原示例的修改 123
5.3.4 本地立方体渲染器 124
5.3.5 本地立方体 131
5.3.6 编译和运行示例 132
5.4 opengl游戏移植到android的问题 137
5.5 大幕已经拉开 138
第6章 3d射击游戏Ⅰ：面向android的wolfenstein 3d 139
6.1 收集工具 139
6.2 wolf 3d 140
6.3 游戏体系结构 143
6.4 wolf 3d的java类 144
6.4.1 创建主要的wolflauncher类 145
6.4.2 创建wolf 3d主菜单 149
6.4.3 处理按键和触控事件 150
6.4.4 创建游戏循环 152
6.4.5 建立本地回调 153
6.4.6 创建声音和音乐处理器 155
6.4.7 创建运动控制器处理程序 156
6.4.8 创建运动控制器 158
6.4.9 声音类 165
6.4.10 本地接口类 174
6.5 编写本地层 176
6.5.1 初始化游戏循环 177
6.5.2 用c到java的回调级联传递消息 179
6.6 编译本地库 185
6.6.1 编写makefile 186
6.6.2 生成jni头文件 187
6.7 在模拟器中测试wolf 3d 187
6.8 下一章内容 189
第7章 3d射击游戏Ⅱ：面向android的doom 191
7.1 java/c组合的无限潜能 191
7.2 将doom引入移动设备 192
7.3 doom的游戏体系结构 194
7.4 java主活动 195
7.4.1 创建处理器 196
7.4.2 游戏布局 197
7.4.3 菜单和选择处理器 199
7.4.4 按键和触控事件处理器 200
7.4.5 本地回调处理器 202
7.4.6 导航控件 205
7.5 音频类 207
7.6 本地接口类 208
7.6.1 回调监听器 208
7.6.2 本地方法 209
7.6.3 c到java的回调 209
7.7 本地层 212
7.7.1 本地方法实现 212
7.7.2 对原游戏的修改 223
7.8 doom库（dso）编译 229
7.9 在模拟器中测试面向android的doom 230
7.10 大功告成 232
附录 部署与编译提示 234

⑻ 学Linux有什么用

1、linux是开放源代码的操作系统，它的每一个操作，你都能够充分了解，并且可以按照你的想法加以修改，这对一个计算机学生或者计算机爱好者来说，无疑是有很大帮助的，它可以让你知道系统是怎样工作。

2、 其次是Linux系统是由C语言写成的，对深入了解和学习C语言的同学无疑是最适合的环境，Linux下使用VI编辑器，让你编码显得高大上，同时VI也是一个让人爱不释手的好工具；Linux里强大的GCC套件，让你随心所欲编译C程序，出色的GDB调试工具，直接让你领悟C语言的原理。

3、据说世界上百分九十以上的服务器都是运行在类Linux系统上，也就是说你日常生活中所有的网络服务，其实都是基于Linux系统的，学好了Linux，你就可以通过管理服务器或者破坏服务器。

(8)straceandroid扩展阅读

Linux是一套免费使用和自由传播的类Unix操作系统，是一个基于POSIX和UNIX的多用户、多任务、支持多线程和多CPU的操作系统。

它能运行主要的UNIX工具软件、应用程序和网络协议。它支持32位和64位硬件。Linux继承了Unix以网络为核心的设计思想，是一个性能稳定的多用户网络操作系统。

Linux操作系统诞生于1991 年10 月5 日（这是第一次正式向外公布时间）。Linux存在着许多不同的Linux版本，但它们都使用了Linux内核。Linux可安装在各种计算机硬件设备中，比如手机、平板电脑、路由器、视频游戏控制台、台式计算机、大型机和超级计算机。

严格来讲，Linux这个词本身只表示Linux内核，但实际上人们已经习惯了用Linux来形容整个基于Linux内核，并且使用GNU工程各种工具和数据库的操作系统。

⑼ Android studio 开发app，如何抵抗动态调试，反调试代码怎么写请写上详细代码。

为了保护关键代码被逆向分析，一般放在应用程序初始化过程中，如init_array，或jni_onload函数里进行检查代码执行。
1.调试检测
对调试器的检测（ida，gdb,strace, ltrace等调试工具）
a.父进程检测
b.当前运行进程检测
例如对android_server进程检测。针对这种检测只需将android_server改名就可绕过
[objc] view plain
pid_t GetPidByName(const charchar *as_name) {
DIR *pdir = NULL;
struct dirent *pde = NULL;
FILEFILE *pf = NULL;
char buff[128];
pid_t pid;
char szName[128];
// 遍历/proc目录下所有pid目录
pdir = opendir("/proc");
if (!pdir) {
perror("open /proc fail.\n");
return -1;
}
while ((pde = readdir(pdir))) {
if ((pde->d_name[0] < '0') || (pde->d_name[0] > '9')) {
continue;
}
sprintf(buff, "/proc/%s/status", pde->d_name);
pf = fopen(buff, "r");
if (pf) {
fgets(buff, sizeof(buff), pf);
fclose(pf);
sscanf(buff, "%*s %s", szName);
pid = atoi(pde->d_name);
if (strcmp(szName, as_name) == 0) {
closedir(pdir);
return pid;
}
}
}
closedir(pdir);
return 0;
}
c.读取进程状态(/proc/pid/status)
State属性值T 表示调试状态，TracerPid 属性值正在调试此进程的pid,在非调试情况下State为S或R, TracerPid等于0

d.读取 /proc/%d/wchan
下图中第一个红色框值为非调试状态值，第二个红色框值为调试状态：

[objc] view plain
static void get_process_status(pid_t pid,const char* info,charchar *outline)
{
FILEFILE *fp;
char filename;
char line = {0};
snprintf( filename, sizeof(filename), "/proc/%d/status", pid );
fp = fopen( filename, "r" );
if ( fp != NULL )
{
while ( fgets( line, sizeof(line), fp ) )
{
if ( strstr( line, info ) )
strcpy(outline,line);
}
fclose( fp ) ;
}
return ;
}
static int getProcessStatus(int pid)
{
char readline = {0};
int result = STATUS_ELSE;
get_process_status(pid,"State",readline);
if(strstr(readline,"R"))
result = STATUS_RUNNING;
else if(strstr(readline,"S"))
result = STATUS_SLEEPING;
else if(strstr(readline,"T"))
result = STATUS_TRACING;
return result;
}
static int getTracerPid(int pid)
{
char readline = {0};
int result = INVALID_PID;
get_process_status(pid,"TracerPid",readline);
charchar *pidnum = strstr(readline,":");
result = atoi(pidnum + 1);
return result;
}
static int getWchanStatus(int pid)
{
FILEFILE *fp= NULL;
char filename;
char wchaninfo = {0};
int result = WCHAN_ELSE;
char cmd = {0};
sprintf(cmd,"cat /proc/%d/wchan",pid);
LOGANTI("cmd= %s",cmd);
FILEFILE *ptr; if((ptr=popen(cmd, "r")) != NULL)
{
if(fgets(wchaninfo, 128, ptr) != NULL)
{
LOGANTI("wchaninfo= %s",wchaninfo);
}
}
if(strncasecmp(wchaninfo,"sys_epoll\0",strlen("sys_epoll\0")) == 0)
result = WCHAN_RUNNING;
else if(strncasecmp(wchaninfo,"ptrace_stop\0",strlen("ptrace_stop\0")) == 0)
result = WCHAN_TRACING;
return result;
}
e. ptrace 自身或者fork子进程相互ptrace
[objc] view plain
ptrace me
if (ptrace(PTRACE_TRACEME, 0, 1, 0) < 0) {
printf("DEBUGGING... Bye\n");
return 1;
}
void anti_ptrace(void)
{
pid_t child;
child = fork();
if (child)
wait(NULL);
else {
pid_t parent = getppid();
if (ptrace(PTRACE_ATTACH, parent, 0, 0) < 0)
while(1);
sleep(1);
ptrace(PTRACE_DETACH, parent, 0, 0);
exit(0);
}
}
f. 防止mp
利用Inotify机制，对/proc/pid/mem和/proc/pid/pagemap文件进行监视。inotify API提供了监视文件系统的事件机制，可用于监视个体文件，或者监控目录。具体原理可参考：http://man7.org/linux/man- pages/man7/inotify.7.html
伪代码：
[objc] view plain
void __fastcall anitInotify(int flag)
{
MemorPagemap = flag;
charchar *pagemap = "/proc/%d/pagemap";
charchar *mem = "/proc/%d/mem";
pagemap_addr = (charchar *)malloc(0x100u);
mem_addr = (charchar *)malloc(0x100u);
ret = sprintf(pagemap_addr, &pagemap, pid_);
ret = sprintf(mem_addr, &mem, pid_);
if ( !MemorPagemap )
{
ret = pthread_create(&th, 0, (voidvoid *(*)(voidvoid *)) inotity_func, mem_addr);
if ( ret >= 0 )
ret = pthread_detach(th);
}
if ( MemorPagemap == 1 )
{
ret = pthread_create(&newthread, 0, (voidvoid *(*)(voidvoid *)) inotity_func, pagemap_addr);
if(ret > 0)
ret = pthread_detach(th);
}
}
void __fastcall __noreturn inotity_func(const charchar *inotity_file)
{
const charchar *name; // r4@1
signed int fd; // r8@1
bool flag; // zf@3
bool ret; // nf@3
ssize_t length; // r10@3
ssize_t i; // r9@7
fd_set readfds; // @2
char event; // @1
name = inotity_file;
memset(buffer, 0, 0x400u);
fd = inotify_init();
inotify_add_watch(fd, name, 0xFFFu);
while ( 1 )
{
do
{
memset(&readfds, 0, 0x80u);
}
while ( select(fd + 1, &readfds, 0, 0, 0) <= 0 );
length = read(fd, event, 0x400u);
flag = length == 0;
ret = length < 0;
if ( length >= 0 )
{
if ( !ret && !flag )
{
i = 0;
do
{
inotity_kill((int)&event);
i += *(_DWORD *)&event + 16;
}
while ( length > i );
}
}
else
{
while ( *(_DWORD *)_errno() == 4 )
{
length = read(fd, buffer, 0x400u);
flag = length == 0;
ret = length < 0;
if ( length >= 0 )
}
}
}
}
g. 对read做hook
因为一般的内存mp都会调用到read函数，所以对read做内存hook，检测read数据是否在自己需要保护的空间来阻止mp
h. 设置单步调试陷阱
[objc] view plain
int handler()
{
return bsd_signal(5, 0);
}
int set_SIGTRAP()
{
int result;
bsd_signal(5, (int)handler);
result = raise(5);
return result;
}

⑽ android preload怎么用

首先看一下Android系统的启动流程：
bootloader
引导程序
kernel
内核
init
init初始化（这个大家都比较熟悉了，不要多说）
loads several daemons and services, including zygote
see /init.rc and init.<platform>.rc
zygote

这个是占用时间最多的，重点修理对象
preloads classes
装载了一千多个类，妈呀！！！
starts package manager 扫描package(下面详细介绍)
service manager
start services （启动多个服务）
从实际的测试数据来看，有两个地方时最耗时间的，一个是zygote的装载一千多个类和初始化堆栈的过程，用了20秒左右。另一个是扫描
/system/app,
/system/framework,
/data/app,
/data/app-private.
这几个目录下面的package用了大概10秒，所以我们重点能够修理的就是这两个老大的。
一、首先是调试工具的使用，可以测试哪些类和那些过程占用了多少时间，
主要工具为
stopwatch
Message loggers
grabserial
printk times
logcat
Android自带
bootchart
strace
AOSP的一部分（Eclair及以上版本）
使用例子
在init.rc中为了调试zygote