tips2

1. 什么是Activity?
activity 是Context的子类
    四大组件之一,  
用户交互界面对应一个activity,处理与窗体用户交互的事件
开发常用的的有ListActivity , PreferenceActivity ,TabAcitivty等…
界面有共同的特点或者功能的时候,还会自己定义一个BaseActivity.


2.请描述一下Activity 生命周期
Activity从创建到销毁有多种状态，会调用对应的回调方法，oncreate ondestroy onstop onstart onresume onpause onRestart；
Activity被onStop后，但是没有被onDestroy，在再次启动此Activity时就调用onRestart（而不再调用onCreate）方法，如果被
onDestroy了，则是调用onCreate方法
onCreate创建与onDestroy销毁;
onStart可见与onStop不可见;
onResume可编辑（即焦点）,在onResume()中打开独占设备（比如相机）
onPause；与onResume()对应的是onPause()，在这个方法中执行停止动画等比较耗CPU的操作,关闭相机的操作也应该在此方法中被调用;
以防止新的Activity也需要在onResume中使用这些资源，同时关闭耗CPU的操作，也有利于新的Activity运行的流畅。


    项目中的经验,比如说客户端每次进入某个界面的时候都要看到最新的数据,这个刷新列表的操作 就放在onStart()的方法里面.保证
每次用户看到的数据都是最新的
    

3.两个Activity之间跳转时必然会执行的是哪几个方法
有两个activity,分别叫A,B ,当在A里面激活B组件的时候, A 会调用 onPause()方法,然后B 调用onCreate() ,onStart(), OnResume() ,
这个时候B覆盖了窗体, A会调用onStop()方法. 如果B呢 是个透明的,或者是对话框的样式, 就不会调用onStop()方法


4.横竖屏切换时候Activity的生命周期
不设置Activity的android:configChanges时，切屏会重新调用各个生命周期，默认首先销毁当前activity,然后重新加载
Onpause onstop ondestory oncreate onstart onresume
    设置Activity的android:configChanges=”orientation|keyboardHidden”时，切屏不会重新调用各个生命周期，只会执行
onConfigurationChanged方法
游戏开发中, 屏幕的朝向都是写死的.


5.如何将一个Activity设置成窗口的样式
做法有两种：
1.在AndroidManifest.xml文件当中设置当前activity的一个属性（系统自带的属性）：android:theme="@android:style/Theme.Dialog"
2.在你的styles.xml文件中可以新建一如下的style:


    在AndroidManifest.xml中在你需要显示为窗口的activity中添加属性：android:theme="@style/Theme.FloatActivity" 即可 
（实质是自定义style，继承的父类style为Theme.Dialog）



6.你后台的Activity被系统回收怎么办？如果后台的Activity由于某原因被系统回收可了，如何在被系统回收之前保存当前状态？
除了在栈顶的activity,其他的activity都有可能在内存不足的时候被系统回收,一个activity越处于栈底,被回收的可能性越大.
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
outState.putLong(“id”, 1234567890);
}

public void onCreate(Bundle savedInstanceState) {
//判断 savedInstanceState是不是空.
//如果不为空就取出来
super.onCreate(savedInstanceState);
}


7.如何退出Activity？如何安全退出已调用多个Activity的Application？
退出activity 直接调用 finish () 方法 . 退出activity 会执行 onDestroy()方法 .
1、抛异常强制退出：该方法通过抛异常，使程序Force Close。验证可以，但是需要解决的问题是，如何使程序结束掉，而不
弹出Force Close的窗口。
//安全结束进程 android.os.Process.killProcess(android.os.Process.myPid());
2.记录打开的Activity：每打开一个Activity，就记录下来。在需要退出时，关闭每一个Activity即可。
List lists ; 在application 全集的环境里面
lists = new ArrayList();
每一个activity在执行oncreate()方法的时候 lists.add(this); Ondestory() lists.remove(this);
lists.add(activity);


for(Activity activity: lists)
{
activity.finish();
}
3.发送特定广播：在需要结束应用时，发送一个特定的广播，每个Activity收到广播后，关闭即可。
//给某个activity 注册接受接受广播的意图
registerReceiver(receiver, filter)
//如果过接受到的是 关闭activity的广播 就调用finish()方法 把当前的activity finish()掉



8. service是否在main thread中执行, service里面是否能执行耗时的操作?
    默认情况,如果没有显示的指定service所运行的进程, Service和activity是运行在当前app所在进程的main thread(UI主线程)里面;
    service里面不能执行耗时的操作(网络请求,拷贝数据库,大文件 ),在子线程中执行 new Thread(){}.start();
特殊情况 ,可在清单文件配置 service 执行所在的进程 ,让service在另外的进程中执行


9. 两个Activity之间怎么传递数据？
基本数据类型可以通过Intent 传递数据: 通过intent.putExtra 方法基本数据类型传递; 获取getIntent(),intent.getExtras取值;
对象传递，对象序列化的有两个选择一个是Parcelable，另外一个是Serializable

一 序列化原因：
1.永久性保存对象，保存对象的字节序列到本地文件中；
2.通过序列化对象在网络中传递对象；
3.通过序列化在进程间传递对象。 

二 选取哪种可参考下面的原则：
1.在使用内存的时候，Parcelable 类比Serializable性能高，所以推荐使用Parcelable类。
 Parcelable 把对象序列化到android操作系统的一块公用的内存空间
2.Serializable在序列化的时候会产生大量的临时变量，从而引起频繁的GC。
3.Parcelable不能使用在要将数据存储在磁盘上的情况，因为Parcelable不能很好的保证数据的持续性在外界有变化的情况下。
尽管Serializable效率低点， 也不提倡用，但在这种情况下，还是建议你用Serializable

Serializable 的实现，只需要继承implements Serializable 即可。这只是给对象打了一个标记，系统会自动将其序列化；
让类实现Serializable 接口，然后可以通过 ObjectOutputStream //对象输出流
File file = new File(“c:\\1.obj”);
FileOutputStream fos = new FileOutputStream(file);
ObjectOutputStream oos = new ObjectOutputStream(fos);


Student stu = new Student();
stu.setId(“10001″);
stu.setName(“zs”);
oos.writeObject(stu);


FileInputStream fis = new FileInputStream(file);
ObjectInputStream ois = new ObjectInputStream(fis);
Student stu1 = (Student) ois.readObject();
System.out.println(stu1.getName()); 

Parcelabel 的实现，需要在类中添加一个静态成员变量 CREATOR，这个变量需要继承 Parcelable.Creator 接口，需要实现
writeToParcel函数。
在读取Parcel容器里的数据时，必须按成员变量声明的顺序读取数据，不然会出现获取数据出错；
public void writeToParcel(Parcel out, int flags) {
out.writeInt(mData);
}

private MyParcelable(Parcel in) {
mData = in.readInt();
}

public static final Parcelable.Creator CREATOR = new Parcelable.Creator() {
public MyParcelable createFromParcel(Parcel in) {
return new MyParcelable(in);
}


public MyParcelable[] newArray(int size) {
return new MyParcelable[size];
}
};



10.怎么让在启动一个Activity是就启动一个service？
在activity的onCreate()方法里面 startService();



11.同一个程序，但不同的Activity是否可以放在不同的Task任务栈中？
比方说在激活一个新的activity时候, 给intent设置flag为singleinstance 单独的任务栈
Intent的flag添加FLAG_ACTIVITY_NEW_TASK，这个被激活的activity就会在新的task栈里面…
Intent intent = new Intent(A.this,B.class);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);

扩展：
   singleinstance设置之后, 本activity与本activity打开的activity是不同的任务, 没错. 当后退的时候, 为什么不是退到桌面? 
        不是因为退出后的栈内还有一个最初的activity. 而是本栈退出了. 就显示到了剩下的那个栈. 那个栈里的栈顶的activity就显示出来了



12. Android Bitmap 内存占用


android 降低内存占用
1.尽量减少new关键字的使用，因为在手机上GC释放一次内存是一件恐怖的事情，如果你查看一下调试记录，你会发现GC释放内存时有时
会花上几百毫秒的时间，可以想象，如果你开发的是游戏，这时你的FPS会下降到多少.
2.原则1：如果可能，请不要使用可变参数;当外部调用可变参数时，系统会自动创建一个临时的数组对象，如果该函数经常被调用，则
会极大增加GC的压力，所以，如果可能，请不要使用可变参数
   3.原则2：如果可能，请用StringBuilder代替字符串的相加；
4.原则3：尽量将不变的东东设置为常数，特别是字符串


android 如何减少应用程序的使用内存？
1.注意资源回收，像数据库，输入输出流，定位操作这样的对象，要在使用完及时关闭流。
2.少使用静态变量，因为系统将静态变量的优先级设定的很高，会最后回收。所以可能因为静态变量导致该回收的没有回收。而回收了
不该回收的内存。
3.注意大图片的缩放，如果载入的图片很大，要先经过自己程序的处理，降低分辨率等。最好设置多种分辨率格式的图片，以减少内存消耗。
4.动态注册监听，把一些只有显示的时候才使用到的监听放进程序内部，而不是放在manifesat中去。
5.减少使用动画，或者适当减少动画的帧数。
6.注意自己的程序逻辑，在该关闭自己程序的控件的时候，主动关闭，不要交给系统去决定。

Android 中 Bitmap 内存回收的一点心得：
1.临时的，已经没用的 bitmap 对象要及时调用 recycle() 释放，
   例如： mBitWallPaper.recycle(); 
      mBitWallPaper = null; 
  System.gc(); //可选

2.Activity中的Bitmap对象，如果是成员变量，需要在onDestroy()中明确释放。 因为，即使在Activity调用Finish()结束后，虚拟机都不
会立即回收Bitmap的内存（什么时候回收不得 而知），所以如一个Activity 中会创建一个很大的Bitmap，在Activiy结束后没有明确释放，多
次调用 这个Activity后，容易发生内存溢出错误


android 内存管理机制、异常、垃圾回收？
当 Android 应用程序退出时，并不清理其所占用的内存，Linux 内核进程也相应的继续存在，所谓“退出但不关闭”。从而使得用户调用程序
时能够在第一时间得到响应。
当系统内存不足时，系统将激活内存回收过程。为了不因内存回收影响用户体验（如杀死当前的活动进程），Android 基于进程中运行的组
件及其状态规定了默认的五个回收优先级：Empty process、Background process、Service process、Visible process、Foreground process


防止内存溢出 1.明确调用System.gc();
2.图片处理完成后回收内存。请在调用BitMap进行图片处理后进行内存回收。  bitmap.recycle();  
  这样会把刚刚用过的图片占用的内存释放。
3.图片处理时指定大小。
 
在Android平台上，长期保持一些资源的引用，造成一些内存不能释放，带来的内存泄露问题很多。比如：Context(下文中提到的Activity都
是Context)，在一些你需要保持你的首个类对象状态，并且把状态传入其他类对象中时，这样消除掉首个类对象之前，你必须先把接收类对象释放
掉。需要注意一点的是：因为在Java或者Android内存机制中，顶点的结点释放前必须保证其他对象没有调用才能被系统GC回收释放。
综上所述，要避免内存泄露，主要要遵循以下几点：
第一：不要为Context长期保存引用(要引用Context就要使得引用对象和它本身的生命周期保持一致)。
第二：如果要使用到Context，尽量使用ApplicationContext去代替Context，因为ApplicationContext的生命周期较长，引用情况下不会造成
内存泄露问题
第三：在你不控制对象的生命周期的情况下避免在你的Activity中使用static变量。尽量使用WeakReference去代替一个static。
第四：垃圾回收器并不保证能准确回收内存，这样在使用自己需要的内容时，主要生命周期和及时释放掉不需要的对象。尽量在Activity的
生命周期结束时，在onDestroy中把我们做引用的其他对象做释放，比如：cursor.close()。

Android默认情况下分配给一个应用程序的内存大小是16M，这对于涉及到大量图片或者后台的应用程序来说，有点吃力，一个不小心，就会出
现OOM的问题，所以，要对应用程序运行过程中的内存使用情况进行测试。


DDMS Heap查看Android应用内存情况
首先，我们在DDMS的界面的设备选项中找到手机设备，可以看到它里面正在运行的进程，点一下“Update Heap"图标，然后在Heap选项中查看
我们标注的进程的内存使用情况。值得关注的就是”data object“的"Total Size"，它决定了是否存在内存泄露的危险。一般情况下，它都是固定
在一个稳定的数值范围，如果回落非常大，或者该数值非常大，说明该应用程序的内存使用情况不佳，代码结构需要优化。点一下"Cause GC", 
相当于向虚拟机执行一次GC请求，然后无需再按就可以动态的查看该应用程序的内存使用情况。


android程序内存被分为2部分：native和dalvik，dalvik就是我们平常说的java堆，我们创建的对象是在这里面分配的，而bitmap是直接在
native上分配的，对于内存的限制是 native+dalvik 不能超过最大限制。android程序内存一般限制在16M，当然也有24M的。
用以下命令可以查看程序的内存使用情况：
adb shell dumpsys meminfo $package_name or $pid    //使用程序的包名或者进程id
其中size是需要的内存，而allocated是分配了的内存，对应的2列分别是native和dalvik，当总数也就是total这一列超过单个程序内存的
最大限制时，OOM就很有可能会出现了。

多数时候，发生OOM 都是在做一些跟图片相关的操作，以下提出一些建议尽量可以减少这种情况的发生：
1.decode bitmap 的时候，尽量配置下Options，例如：inSameSize；
2.Bitmap使用完以后，调用 bitmap.recycle()来释放内存；
3.如果应用是基于图片的应用，尽量采用LazyLoad和DymanicRecycle；
4.decode bitmap 的时候，将decode代码 try catch 出来，catch oom error，避免程序crash，可以在catch里面做一些释放内存操作

查看android程序的CPU和内存消耗情况 ：
查看CPU 消耗：1.进入adb shell
 2.输入top -m 10 -s cpu 可查看占用cpu最高的前10个程序
 （-t 显示进程名称，-s 按指定行排序，-n 在退出前刷新几次，-d 刷新间隔，-m 显示最大数量）

查看内存消耗：1.进入adb shell ;
 2.输入dumpsys meminfo (PID或者是包名)
 
分析内存：  1.通过DDMS，选择想要查看的程序进程，点击update heap;
 2.在heap界面中查看内存消耗情况  


想要进一步分析，需要借助于MAT 插件

再看开发过程中，经常要通过内存的使用量来优化程序。查看应用程序的命令：
adb shell procrank  
显示如下：
 PID      Vss      Rss      Pss      Uss  cmdline
 190   79560K   74736K   49624K   43604K  system_server
14335   55776K   55740K   31308K   26676K  com.android.launcher2
13074   47408K   47380K   24947K   22428K  com.android.settings
注：
VSS - Virtual Set Size 虚拟耗用内存（包含共享库占用的内存）
RSS - Resident Set Size 实际使用物理内存（包含共享库占用的内存）
PSS - Proportional Set Size 实际使用的物理内存（比例分配共享库占用的内存）
USS - Unique Set Size 进程独自占用的物理内存（不包含共享库占用的内存）

查看单个应用程序内存占用量的命令：adb shell dumpsys meminfo $包名 或者 $进程号 ，有了这些，调试应用程序的内存问题容易多了


内存泄露就是你保留了一个并不再需要的类对象的引用。有时候仅仅一个引用就会阻碍gc对一大堆对象的回收。


(一) 查询数据库没有关闭游标；
(二) 构造Adapter时，没有使用缓存的 convertView ；
(三) Bitmap对象不在使用时调用recycle()释放内存 ；
(四) 将变量的作用域设置为最小；
(五) 仅当你确实需要时才初始化 
(六) 不要在循环中定义变量
(九) 简单的使用 finally 块 
finally 块即使 try 或 catch 执行不成功的时候也会执行,也就是说即使在 try 或 catch 中出现了任何异常,finally 块中的语句绝对
也会执行。将清理内存的语句放在这里以保证内存被清理
(十) 分散对象创建或删除的时间  集中在短时间内大量创建新对象,特别是大对象,会导致突然需要大量内存,JVM在面临这种情况时,只能
进行主GC,以回收内存或整合内存碎片,从而增 加主GC的频率。集中删除对象,道理也是一样的。它使得突然出现了大量的垃圾对象,空闲空间
必然减少,从而大大增加了下一次创建新对象时强制主GC的机 会。


为什么内存少的时候运行大型程序会慢呢？其实很简单，在内存剩余不多时打开大型程序，会触发系统自身的调进程调度策略，这是十分
消耗系统资源的操作，特别是在一个程序频繁向系统申请内存的时候。这种情况下系统并不会关闭所有打开的进程，而是选择性关闭，频繁的
调度自然会拖慢系统。


如果不关程序是不是会更耗电？
android的应用在被切换到后台时，它其实已经被暂停了，并不会消耗cpu资源，只保留了运行状态。所以为什么有的程序切出去重进会到
主界面。但是，一个程序如果想要在后台处理些东西，如音乐播放，它就会开启一个服务。服务可在后台持续运行，所以在后台耗电的也只有
带服务的应用了。这个在进程管理软件里能看到，标签是service。至于广播什么的我就不涉及了。所以没有带服务的应用在后台是完全不耗
电的，没有必要关闭。这种设计本来就是一个非常好的设计，下次启动程序时，会更快，因为不需要读取界面资源。


为什么android一个应用看起来那么耗内存？
android上的应用是带有独立虚拟机的，也就是每开一个应用就会打开一个独立的虚拟机。这样设计的原因是可以避免虚拟机崩溃导致整
个系统崩溃，但代价就是需要更多内存。这些设计确保了android的稳定性，正常情况下最多单个程序崩溃，但整个系统不会崩溃，也永远没
有内存不足的提示出现。


机子开机内存怎么只有200m啦，用一会怎么就变成100多m？
Android系统 是 基于Linux 2.6内核开发的开源操作系统，而linux系统的内存管理有其独特的动态存储管理机制。不过Android系统对
Linux的内存管理机制进行了优化，Linux系统会在进程活动停止后就结束该进程，而Android把这些进程都保留在内存中，直到系统需要更
多内存为止。这些保留在内存中的进程通常情况下不会影响整体系统的运行速度，并且当用户 再次激活这些进程时，提升了进程的启动速度。
如果你懂java，就会更容易理解Android系统的内存管理机制。与java的内存回收机制类似，系统有一个规则来回收内存。进行内存调度
有个阈值，只有低于这个值系统才会按一个列表来关闭用户不需要的东西。Android系统有六类进程：前台进程、可见进程、次要服务、后台
进程、内容供应节点、空进程。对于高手 而言可以用MinFreeManager之类的软件进行进程管理，分别为六类进程设定不同的阈值来操纵系统
的内存分配机制。不过对于一般用户而言，Android系统默认的分配机制已经可以满足使用需要，因此也不需要再去调整。

对于一些内存很低的低端Android机而言，系统默认的内存分配机制无法实现很完善的内存调配。所以在运行大型游戏时需要先清理一下
内存。512m的总内存和几十m的空余内存已经可以充分的满足系统自动调配的需要，因此完全没有必要老去杀进程、清内存。有的兄弟说后台
挂着程序很费电，事实上Android的应用在被切换到后台时，它其实已经被暂停了，并不会消耗cpu资源，只保留了运行状态。至于QQ、音乐
播放之类的程序可以在后台运行，是因为这些程序在后台开启了服务，而服务可以后台运行，所以没有带服务的应用在后台是完全不耗电的，
没有必要关闭。这种设计本来就是一个非常好的设计，下次启动程序时，会更快，因为不需要读取界面资源。

Android系统这样的设计不仅非常适合移动终端的需要，而且减少了系统崩溃的可能，确保了系统的稳定性。老想着清理内存的同学完全
是因为被塞班或者 Windows毒害太深，事实上，经常用Taskiller之类的软件关闭后台所有进程，很容易造成系统的不稳定。很多时候出现问
题，只要重启就能解决，其原因也在于此。

说了这么多，总结起来很简单，牛B的人自己去操纵系统内存分配的阈值，而普通用户则是想怎么用就怎么用，完全不用去鸟剩余内存的
问题，那些内存清理的程序完全可以扔到一边了。

Android并没有在进程活动停止就释放对应的内存.那么也许你还是会有疑问,那么内存够不够用呢?512的内存被我用的只剩56M是不是很?
其实系统一点也不卡的,蛋定蛋定。事实上呢,Android会在系统需要更多内存的时候,去释放掉那些占用内存的进程----这个活动是智能的.
Android把进程分成了一些优先级,比如
前台进程(Foreground),比如我们正在看书,那么看书的程序就是前台进程,这些进程是不会被系统优先结束的.当我把它切到后台的时候,
它就变成后台进程了。



PS：
1.按home退出，程序保留状态为后台进程；按返回键退出，程序保留状态为空进程。空进程的oom_adj评值高于后台进程，更容易被系统
清理。所以推荐用返回键退出。
2.UC、愤怒小鸟、都市赛车之类程序本身提供关闭功能 的，还是尽量主动关闭。浏览器 、电子市场、opera mini等不提供关闭功能的，
直接返回键退出就行。



Android资源图片内存占用及优化
优化的两种方式：
1.大背景图使用：9.png,使用9png不但能节省APK包容量，更能有效节省堆栈内存
2.使用多分辨率图片设计[hdpi,mdpi,ldpi,xhdpi]。UI图片分别设计hdpi,mdpi,ldpi,xhdpi等多种规格，这也是官方推荐的方式，
使用这种方式，还有好处就是可以降低峰值内存，优先避免内存溢出。在android中图片的加载会根据分辨率来自动缩放【缩放的过程会
额外消耗内存】。
3.图片资源放在assets或no-dpi中，也可以避免因缩放导致峰值内存过高，如果你的程序经常因加载某图片溢出，但又想继续使用的话，
你也可以直接使用:


Android的虚拟机是基于寄存器的Dalvik，它的最大堆大小一般是16M，有的机器为24M。因此我们所能利用的内存空间是有限的。如果我们
的内存占用超过了一定的水平就会出现OutOfMemory的错误。
为什么会出现内存不够用的情况呢？我想原因主要有两个：
由于我们程序的失误，长期保持某些资源（如Context）的引用，造成内存泄露，资源造成得不到释放。
保存了多个耗用内存过大的对象（如Bitmap），造成内存超出限制。


超级大胖子Bitmap，可以说出现OutOfMemory问题的绝大多数人，都是因为Bitmap的问题。因为Bitmap占用的内存实在是太多了，它是一个
“超级大胖子”，特别是分辨率大的图片，如果要显示多张那问题就更显著了。如何解决Bitmap带给我们的内存问题？
第一、及时的销毁。虽然，系统能够确认Bitmap分配的内存最终会被销毁，但是由于它占用的内存过多，所以很可能会超过java堆的限制。
因此，在用完Bitmap时，要及时的recycle掉。recycle并不能确定立即就会将Bitmap释放掉，但是会给虚拟机一个暗示：“该图片可以释放了”。
第二、设置一定的采样率。有时候，我们要显示的区域很小，没有必要将整个图片都加载出来，而只需要记载一个缩小过的图片，这时候
可以设置一定的采样率，那么就可以大大减小占用的内存。
第三、巧妙的运用软引用（SoftRefrence），有些时候，我们使用Bitmap后没有保留对它的引用，因此就无法调用Recycle函数。这时候
巧妙的运用软引用，可以使Bitmap在内存快不足时得到有效的释放。

其实，要减小内存的使用，其实还有很多方法和要求。比如不要使用整张整张的图，尽量使用9path图片。Adapter要使用convertView等。

如何做好团队管理
小成功靠个人， 大成功靠团队，从两个角度谈：人员管理、项目管理


人员管理方面：
1.充分认识到各自的工作特点和能力长短，各尽其能，发挥团队成员能力和积极性
2.诚恳大方，客观待人待事，注重沟通，大家相互认同和信任
3.善于倾听他人观点，给出自己方案建议；能力强的人可以引导点拨，能力差点的人教导
4.团队学习能力培养，经验交流

项目管理方面：
1.对项目关键点的细节要足够了解，掌控技术关键点：
特别是一些影响项目成败的关键点、可行性分析验证，项目规模不大的情况下，PM兼任架构师；
如果自身在技术上缺乏深入，对细节不够了解，会直接影响他的判断力和全局控制力

2.对项目各个阶段的时间点要足够清晰，做好计划，控制风险：
有一个清晰的项目进度管理计划，对每个时间点做好准备，项目立项前，预估好工作量和资源分配，与其他团队协调好时间点和容错方案；
需求评审前得组织项目骨干了解需求并做好架构设计，与PD深入探讨，避免业务上走不通；设计评审前，得评估出所有风险点和合作方，并完
成设计文档，与合作方充分探讨合作细节，并达成一致；提交测试前，关注各个任务的进度，特别是有风险的，并为测试准备好环境；发布前，
做好发布计划，预估出发布风险点。总之，需要对各个关键时间点有清晰的认识，提前做好准备，控制好风险。


3.处理好与其他团队的关系：
一个项目的成功不是只靠自己这个团队就能做到的，需要所有团队的通力合作，因此，非常有必要学会与其他团队处理好关系，弄清楚什
么是原则性问题，什么是可以退让的，在有分歧的时候，判断出是否可以出做让步。再则，把问题想在前面，提前沟通，只要大家都是为了把
项目做好，把可能的分歧点讨论清楚了，就没什么很难处理的关系。

4.调动组员的积极性，尽量把事情让他人去做好：
锻炼和培养其他组员，发挥他们的最大潜力，这样项目团队才有整体战斗力

5.处理好风险点：代码Review
PM可以把不影响项目成败的点扔给你信任的人，但对于那些会导致失败的风险点必须给予足够的重视。如果在线上暴露了出来，造成了不
小的损失和不良影响。

6.安排好任务，并清晰了解任务的进度：
任务交给最合适的人，并保持与他们的深入沟通，了解他们面临的困难，让自己和他人清晰看到各个任务的完成情况，便与跟进。

7.保持清晰的思路，储备应对各种突发事件的措施：
多做项目发布、设计评审和数据订正的工作，并且要有意识地储备一些应急方案，比如代码回滚，紧急发布等；
清晰地弄清楚团队之间和系统之间的依赖关系，往往这种依赖性是引发事件的根源；


8.保持平和的心态，多站在他人立场考虑问题 ：
平和的心态沟通，分歧方也会不由自主地为你考虑，有利于解决问题，达成一致

9.加强项目自动化方面的能力：
用成熟的自动化方案去完成一些工作，特别是项目构建、持续集成和发布等工作；

10.共识和决议要通过邮件发给相关人 ：
项目过程中会产生很多变更，需求和设计文档里定义不了所以问题，为解决变故而形成的临时决议一定要通过邮件发给相关人，不光是
知会，更重要的是为决议提供证据，这些临时的决议往往会引发问题，当问题产生追溯责任时需要用到这些证据

11.注意倾听组员的意见，给他们留出足够的发挥空间 ：
特别是在大公司带项目，组员都算是开发的精英，都不是甘于做个机械的coder，因此学会倾听他们的想法，深入了解他们想得到的，
尽量满足他们成长需求，就算是由于项目客观原因，没法采纳他们的建议，也得和他们把道理说清楚，不合适用强势方式来决断，毕竟
技术人员的需求和管理不同一般。

12.不以个人意愿为基准，凡是以大局为重 
说话做事一定要三思而行，考虑清楚对别人的影响，切勿乱放炮，失去同仁的信任;

   我认为项目领导者有几个特性：
   自身技术扎实；注意节点控制；善于和员工沟通；为人有亲和力；
自己很闲，但是员工工作很充实；知人善用；
深入了解项目细节，做事有计划；有创新能力；
有解决突发事件的能力。