Android应用程序组成部分 Manifest文件 Manifest文件节点

本文我们讲讲Android开发中比较高级的内容，应用程序组成部分，Manifest文件，Manifest文件节点，在Android平台的应用程序开发过程中,Manifest文件举足轻重。每一个应用程序都要有一个Manifest文件,他配置了应用程序在Android系统上的基本信息。

Android应用程序的组成部分和Manifest文件

Android应用程序由松散耦合的组件组成，并使用应用程序Manifest绑定到一起；应用程序Manifest描述了每一组件和它们之间的交互方式，还用于指定应用程序元数据、其硬件和平台要求、外部库以及必需的权限。

一、应用程序的基本结构模块

　　· Activity：应用程序的表示层。每个UI都是通过Activity类的一个或多个扩展实现的。Activity使用Fragment和视图来布局和显示信息，以及响应用户动作。

　　· Service：应用程序中不可见的工作者。运行时没有UI，可以更新数据源和Activity、触发通知和广播Intent。可以用来执行一个运行时间长的任务，或者不需要和用户交互的任务。

　　· Content Provider：可共享的持久数据存储器（内容提供者）。用来管理和持久化应用程序数据，通常会与SQL数据库交互。可以通过配置自己的Content Provider来允许其他应用程序访问，也可以访问其他应用。

　　· Intent：消息传递框架。Android中大量使用了Intent、Service或者Broadcast Receiver广播消息，以及请求对特定的一条数据执行操作。

　　· Broadcast Receiver： Intent侦听器（广播接收者）。可以监听到那些匹配指定的过滤标准的Intent广播。它会自动地启动应用程序来响应某个接收到Intent。

　　· Widget：可视化应用程序组件。它是Broadcast Receiver的特殊变体，可用于创建动态的交互式应用程序组件，用户可以把这些组件添加到他们的主屏幕上。

　　· Notification：它允许向用户发送信号，但却不会过分吸引他们的注意力或者打断他们当前的Activity。它们是应用程序不可见或者不活动时吸引用户注意的首选方法。

二、Manifest文件简介

　　每一个Android项目都包含一个Manifest文件——Android Manifest.xml，它存储在项目层次中的最底层。Manifest可以定义用用程序及其组件和需求的结构和元数据。

　　Manifest包含了组成应用程序的每一个Activity、Service、Content Provider和Broadcast Receiver的节点，并使用Intent Filter和权限来确定这些组件和其他应用程序是如何交互的。此文件还可以指定应用程序的元数据（图标、版本号、主题等等） 以及额外的顶层节点，这些节点可以指定必需的安全权限和单元测试，以及定义硬件、屏幕和平台支持要求。

　　Manifest文件有一个根manifest标签构成，该标签带有一个被设为项目包的package属性。它通常包含一个xmls:android属性来提供文件内使用的某些系统属性。

　　使用versionCode属性可讲当前的应用版本定义为一个整数，每次版本更新，这个数字都会增加。使用versionName可以定义一个显示给用户的公共版本号。

　　installLocation属性，是制定是否允许将程序安装到SD卡上，其值有preferExternal（首选外部存储器）和auto（系统决定）。不指定时，默认按到内部存储器中。由于取出或拒绝外部存储器存在的问题，以下程序不适合安装到外部存储器及其后果：

　　· 具有Widget／Live Wallpaper和Live Folder的应用程序： Widget／Live Wallpaper和Live Folder将从主屏幕上移除，而且重启系统后可能不在可用。

　　· 提供不中断服务的应用程序：程序和它运行的服务将被停止，并且不会自动重启。

　　· 输入法引擎：安装到外部存储器的任何IME都会被禁用。在外部存储器再次可用后，用户必须重新选择IME。

　　· 设备管理器：DeviceAdminReceiver及其管理能力将被禁用。


Manifest文件节点详解

首先看一下Manifest文件最基本的结构：

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.codingblock.manifesttest"
    android:versionCode="1"
    android:versionName="1.0"
    android:installLocation="preferExternal" >
    <!-- ...nodes... -->
</manifest>

　　manifest标签包含了一些节点（node），定义了组成应用程序的应用程序组建、安全设置、测试类和需求。下面是一些manifest子节点标签：

　　· uses-sdk：要想正确的运行程序，需要有minSKDVersion（默认值：1）、maxSDKVersion和targetSDKVersion属性。

　　· uses-configuration：使用此节点可以指定应用程序支持的每个输入机制的组合。一般不需要包含这个节点，不过对于需要特殊输入控制的游戏说很有用。以下是它的几个属性：

　　　　· reqFiveWayNav：要求设备有上、下、左、右导航，并且能够单击当前的选项时为true。包括跟踪求和D-pad。

　　　　· reqHarKeyboard：要求设备有硬件键盘时为true。

　　　　· reqKeyboardType：指定键盘类型为nokeys、qwerty、twelvekey、undefined。

　　　　· reqNavigation：导航设备（值：nonav、dpad、trackball、wheel或undefined）。

　　　　· reqTouchScreen：以指定必需的触摸屏输入（notouch、stylus、finger或undefined）。

　　· uses-feature：Android可以在各种各样硬件平台上运行。可以使用多个uses-feature节点来指定应用程序需要的每个硬件功能，以避免安装到不包含硬件功能的设备上。（如：NFC、蓝牙、摄像头等等）

　　· supports-screens：用于指定应用程序针对那些屏幕尺寸惊醒了设计和测试。当应用程序支持某个设备的屏幕是，一般就会使用开发人员提供的布局文件中的缩放属性来布局。在不支持的设备上运行时，系统可能会应用“兼容模式”来显示应用程序。

　　· supports-gl-texture：用于声明应用程序能够提供以一种特定的GL纹理压缩格式压缩的纹理资源。如果应用程序能够多种纹理压缩格式，就必须使用多个supports-gl-texture元素。

　　· uses-permission：声明应用程序所需权限。

　　· permission：应用程序组件也可以创建权限来限制对共享应用程序组件的访问。（可以使用permission标签来创建权限定义）

　　· instrumentation：instrumentation类提供了一个测试框架，用来在应用程序运行时测试应用程序组件。

　　· application：一个Manifest只能包含一个application节点。用于指定应用程序的各种元数据（标题、图标和主题）。在开发时，建议将debuggable设为true，以启用调试，发布时可以禁用此属性。application节点包含了Activity、Service、Content Provider和Broadcast Receiver等子节点。并通过创建和是用自己的Application类扩展来管理应用程序的状态。

<application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme"
        android:debuggable="true" >
        <!-- ...nodes... -->
    </application>

以下是对application子节点的简单介绍：

· activity：应用程序的每一个Activity都需要一个此节点，并使用andorid:name属性来指定Activity类的名称。必须包含核心的启动Activity和其他所有可显示的Activity。启动一个没有定义的Activity就会抛出运行时异常。每一个activity节点都可以使用intent-filter子标签来定义用于启动该Activity的Intent。（指定类名时，可以使用“.”作为简写方式代替应用程序的包名）如下代码：

<activity
    android:name="com.codingblock.manifesttest.MainActivity"
    android:label="@string/app_name" >
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>

· service和activity标签一样，需要为应用程中使用的每一Service类添加一个此标签。同样它也支持使用intent-filter子标签来进行运行时绑定。

<service android:name=".MyService">
</service>

· provider：此标签用于指定应用程序中的每一Content Provider。（Content Provider用来管理数据库访问和共享）

<provider android:name=".MyContentProvider"
    android:authorities="com.codingblock.manifesttest.MyContentProvider">
</provider>

· receiver：通过添加receiver标签，可以注册一个Broadcast Receiver，而不用事先启动应用程序。一旦注册了之后，无论何时，只要与它相匹配的Intent被系统或应用程序广播出来，它就会立即执行。通过在manifest中注册一个Broadcast Receiver，可以使这个进程实现完全自治。如果一个匹配的Intent被广播了，则应用程序就会自动启动，并且你注册的Broadcast Receiver也会开始执行。每一个receiver节点都允许使用intent-filter子标签来定义可以用来触发接收器的Intent：

<receiver android:name=".MyIntentReceiver">
    <intent-filter>
        <action android:name="com.codingblock.manifesttest.MyIntentReceiver"/>
    </intent-filter>
</receiver>

· uses-library：用于指定该应用程序需要的共享库。

本教程我们主要学习在Android开发中ExecutorService线程池的应用，如何创建线程池；调用线程池的方法，获取线程执行完毕后的结果；关闭线程等。

首先我们先了解一下到底什么是线程池，只有了解了其中的道理，我们才能够进行应用...java.util.concurrent.ExecutorService表述了异步执行的机制

首先我们简单的举一个例子...

package executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Executor {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("cc");
        ExecutorService executorService=Executors.newFixedThreadPool(10);
        executorService.execute(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                while(true){
                    
                    System.out.println("aa");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        });
        System.out.println("bb");
    }
}

这里我们指定了十个线程处于一个线程池内部，线程池的原理其实就是对多线程的一个管理，为了实现异步机制的一种方法，其实就是多个线程执行多个任务，最终这些线程通过线程池进行管理...不用手动去维护...一次可以处理多个任务，这样就可以迅速的进行相应...比如说一个网站成为了热点网站，那么对于大量的点击量，就必须要对每一次的点击做出迅速的处理，这样才能达到更好的交互效果...这样就需要多个线程去处理这些请求，以便能够更好的提供服务...

1. 简单的说一下如何创建线程池进行初始化....创建线程有几种常用方式...这里都是使用了Executors工厂来实例化对象，同时我们也可以根据需求自己去写一个ExecutorService...这几种常用的方法有一定的区别...

ExecutorService executorService1 = Executors.newSingleThreadExecutor();

ExecutorService executorService2 = Executors.newFixedThreadPool(10);

ExecutorService executorService3 = Executors.newScheduledThreadPool(10);

ExecutorService executorService4 = Executors.newCacheThreadPool();

Executors.newSingleThreadExecutor()

单例线程，表示在任意的时间段内，线程池中只有一个线程在工作...

Executors.newCacheThreadPool()

缓存线程池，先查看线程池中是否有当前执行线程的缓存，如果有就resue(复用),如果没有,那么需要创建一个线程来完成当前的调用.并且这类线程池只能完成一些生存期很短的一些任务.并且这类线程池内部规定能resue(复用)的线程，空闲的时间不能超过60s,一旦超过了60s,就会被移出线程池.
Executors.newFixedThreadPool(10)     固定型线程池，和newCacheThreadPool()差不多，也能够实现resue(复用),但是这个池子规定了线程的最大数量，也就是说当池子有空闲时，那么新的任务将会在空闲线程中被执行，一旦线程池内的线程都在进行工作，那么新的任务就必须等待线程池有空闲的时候才能够进入线程池,其他的任务继续排队等待.这类池子没有规定其空闲的时间到底有多长.这一类的池子更适用于服务器.
Executors.newScheduledThreadPool(10)     

调度型线程池,调度型线程池会根据Scheduled(任务列表)进行延迟执行，或者是进行周期性的执行.适用于一些周期性的工作.

这就是线程池创建的几种方式...我们需要根据不同的需求来适当的选择到底使用哪种线程池...

2.那么创建了线程池以后就需要对线程池进行调用..将任务加载到其中...

i.ExecutorService.execute(Runnable);

第一种调用方式...通过这种方式将线程任务加载到线程池当中...我们可以添加多个任务...贴上一个完整的代码...大家看一下代码的解释就明白到底是怎么回事了..不难理解...

package executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Executor {
    /**
     * @param args
     * 
     */
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ExecutorService executorService=Executors.newFixedThreadPool(2);//定义了线程池中最大存在的线程数目...
        
        //添加了第一个任务...这个任务会一直被执行...
        executorService.execute(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                while(true){
                    
                    System.out.println("aa");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        });
        
        //添加第二个任务，被执行三次停止...
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                int i=0;
                while(true){
                    i++;
                    System.out.println("bb");
                    if(i==3){
                        break;
                    }
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }    
                }
            }
        });
        
        /*
         * @param
         * 第三个任务...只有当第二个任务被执行三次之后才能被执行...
         * 由于三次前，线程池已经满了,这个任务是轮不到被执行的..只能排队进行等待. 
         * 三次之后，第二个任务被终止，也就是线程池中出现了空闲的状态，所以这个任务将被放入到线程池中执行...
         * */
        executorService.execute(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                while(true){
                    
                    System.out.println("cc");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        });
    }
}

ii.executorService.submit(Runnable) 第二种调用方式...这种方式与第一种的区别在于可以使用一个Future对象来判断当前的线程是否执行完毕...但是这种方法只能判断当前的线程是否执行完毕，无法返回数据信息...

Future future = executorService.submit(new Runnable() {
    public void run() {
        System.out.println("Asynchronous task");
    }
});
//如果任务结束执行则返回 null
System.out.println("future.get()=" + future.get());

  iii.executorService.submit(Callable)...  第三种调用方式...这种调用方式与前一种有所不同，传递的参数为Callable对象，Callable与Runnbale很相似，但是Callable的call()方法可以返回数据信息...通过Future就能够获取到其中的信息..而Runnbale.run()方法时无法获取数据信息的....Future应用于多线程...可以获取call()方法返回的数据信息...其实他是一种模式，是为了性能优化而提供的一种思想...这里我就不说Future...

uture future = executorService.submit(new Callable(){
    public Object call() throws Exception {
        System.out.println("Asynchronous Callable");
        return "Callable Result";
    }
});
System.out.println("future.get() = " + future.get());
//上述样例代码会输出如下结果： 
//Asynchronous Callable
//future.get() = Callable Result

iv.inVokeAny()...第四种调用方式...方法 invokeAny() 接收一个包含 Callable 对象的集合作为参数。调用该方法不会返回 Future 对象，而是返回集合中某一个 Callable 对象的结果，而且无法保证调用之后返回的结果是哪一个Callable，只知道它是这些 Callable 中一个执行结束的 Callable 对象...说实话这个方法我不知道它创建的目的到底是什么...这里执行后的结果是随机的...也就是输出是不固定的....

ExecutorService executorService = Executors.newSingleThreadExecutor();
Set<Callable<String>> callables = new HashSet<Callable<String>>();
callables.add(new Callable<String>() {
    public String call() throws Exception {
        return "Task 1";
    }
});
callables.add(new Callable<String>() {
    public String call() throws Exception {
        return "Task 2";
    }
});
callables.add(new Callable<String>() {
    public String call() throws Exception {
        return "Task 3";
    }
});
String result = executorService.invokeAny(callables);
System.out.println("result = " + result);

v.inVokeAll()这个方法和上面不同的地方就在于它可以返回所有Callable的执行结果...获取到所有的执行结果，我们可以对其进行管理...相对而言，我觉得这个方法比上一个更实用吧...

ExecutorService executorService = Executors.newSingleThreadExecutor();
Set<Callable<String>> callables = new HashSet<Callable<String>>();
callables.add(new Callable<String>() {
    public String call() throws Exception {
        return "Task 1";
    }
});
callables.add(new Callable<String>() {
    public String call() throws Exception {
        return "Task 2";
    }
});
callables.add(new Callable<String>() {
    public String call() throws Exception {
        return "Task 3";
    }
});
List<Future<String>> futures = executorService.invokeAll(callables);
for(Future<String> future : futures){
    System.out.println("future.get = " + future.get());

3.线程池的关闭...

当我们不需要使用线程池的时候，我们需要对其进行关闭...有两种方法可以关闭掉线程池...

i.shutdown()...

  shutdown并不是直接关闭线程池，而是不再接受新的任务...如果线程池内有任务，那么把这些任务执行完毕后，关闭线程池....

ii.shutdownNow()

  这个方法表示不再接受新的任务，并把任务队列中的任务直接移出掉，如果有正在执行的，尝试进行停止...

大家自己试着运行下面的代码就了解其中到底是怎么回事了...

package executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Executor {
    /**
     * @param args
     * 
     */
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ExecutorService executorService=Executors.newFixedThreadPool(1);//定义了线程池中最大存在的线程数目...
        
        //添加了第一个任务...这个执行三次停止...
        executorService.execute(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                int j=0;
                while(true){
                    j++;
                    System.out.println("aa");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    if(j==3){
                        break;
                    }
                }
            }
        });
        
        //添加第二个任务，由于使用executorService.shutdown()，由于它的加入是在这个方法调用之前的，因此这个任务也会被执行...
        //如果我们使用了executorService.shutdownNow();方法，就算是他在之前加入的，由于调用了executorService.shutdownNow()方法
        //那么这个任务将直接被移出队列并且不会被执行...
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                int i=0;
                while(true){
                    i++;
                    System.out.println("bb");
                    if(i==3){
                        break;
                    }
                }
            }
        });
        executorService.shutdown();//这里无论使用了那种方法,都会抛出一个异常...
        /*
         * @param
         * 第三个任务...只有当第二个任务被执行三次之后才能被执行...
         * 由于三次前，线程池已经满了,这个任务是轮不到被执行的..只能排队进行等待. 
         * 三次之后，第二个任务被终止，也就是线程池中出现了空闲的状态，所以这个任务将被放入到线程池中执行...
         * */
        executorService.execute(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                while(true){
                    
                    System.out.println("cc");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        });
    }
}

ExecutorService线程池的用法


 在Java5之后，并发线程这块发生了根本的变化，最重要的莫过于新的启动、调度、管理线程的一大堆API了。在Java5以后，通过 Executor来启动线程比用Thread的start()更好。在新特征中，可以很容易控制线程的启动、执行和关闭过程，还可以很容易使用线程池的特性。

一、创建任务

任务就是一个实现了Runnable接口的类。
创建的时候实run方法即可。

二、执行任务

通过java.util.concurrent.ExecutorService接口对象来执行任务，该接口对象通过工具类java.util.concurrent.Executors的静态方法来创建。
Executors此包中所定义的 Executor、ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 类的工厂和实用方法。
ExecutorService提供了管理终止的方法，以及可为跟踪一个或多个异步任务执行状况而生成 Future 的方法。 可以关闭 ExecutorService，这将导致其停止接受新任务。关闭后，执行程序将最后终止，这时没有任务在执行，也没有任务在等待执行，并且无法提交新任务。
executorService.execute(new TestRunnable());

1、创建ExecutorService

通过工具类java.util.concurrent.Executors的静态方法来创建。
Executors此包中所定义的 Executor、ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 类的工厂和实用方法。
比如，创建一个ExecutorService的实例，ExecutorService实际上是一个线程池的管理工具：
ExecutorService executorService = Executors.newCachedThreadPool();
ExecutorService executorService = Executors.newFixedThreadPool(3);
ExecutorService executorService = Executors.newSingleThreadExecutor();

2、将任务添加到线程去执行

当将一个任务添加到线程池中的时候，线程池会为每个任务创建一个线程，该线程会在之后的某个时刻自动执行。

三、关闭执行服务对象

executorService.shutdown();

五、获取任务的执行的返回值

在Java5之后，任务分两类：一类是实现了Runnable接口的类，一类是实现了Callable接口的类。两者都可以被 ExecutorService执行，但是Runnable任务没有返回值，而Callable任务有返回值。并且Callable的call()方法只能通过ExecutorService的(<T> task) 方法来执行，并且返回一个 <T><T>，是表示任务等待完成的 Future。
public interface Callable<V>
返回结果并且可能抛出异常的任务。实现者定义了一个不带任何参数的叫做 call 的方法。
Callable 接口类似于，两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果，并且无法抛出经过检查的异常。
类包含一些从其他普通形式转换成 Callable 类的实用方法。
Callable中的call()方法类似Runnable的run()方法，就是前者有返回值，后者没有。
当将一个Callable的对象传递给ExecutorService的submit方法，则该call方法自动在一个线程上执行，并且会返回执行结果Future对象。
同样，将Runnable的对象传递给ExecutorService的submit方法，则该run方法自动在一个线程上执行，并且会返回执行结果Future对象，但是在该Future对象上调用get方法，将返回null。
遗憾的是，在Java API文档中，这块介绍的很糊涂，估计是翻译人员还没搞清楚的缘故吧。或者说是注释不到位。下面看个例子：

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
publicclass CallableDemo {
publicstaticvoid main(String[] args) {
ExecutorService executorService = Executors.newCachedThreadPool();
List<Future<String>> resultList = new ArrayList<Future<String>>();
//创建10个任务并执行
for (int i = 0; i < 10; i++) {
//使用ExecutorService执行Callable类型的任务，并将结果保存在future变量中
Future<String> future = executorService.submit(new TaskWithResult(i));
//将任务执行结果存储到List中
resultList.add(future);
}
//遍历任务的结果
for (Future<String> fs : resultList) {
try {
System.out.println(fs.get()); //打印各个线程（任务）执行的结果
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
} finally {
//启动一次顺序关闭，执行以前提交的任务，但不接受新任务。如果已经关闭，则调用没有其他作用。
executorService.shutdown();
}
}
}
}
class TaskWithResult implements Callable<String> {
privateint id;
public TaskWithResult(int id) {
this.id = id;
}
public String call() throws Exception {
System.out.println("call()方法被自动调用,干活！！！ " + Thread.currentThread().getName());
//一个模拟耗时的操作
for (int i = 999999; i > 0; i--) ;
return"call()方法被自动调用，任务的结果是：" + id + " " + Thread.currentThread().getName();
}
}

运行结果：

call()方法被自动调用,干活！！！ pool-1-thread-1
call()方法被自动调用,干活！！！ pool-1-thread-3
call()方法被自动调用,干活！！！ pool-1-thread-4
call()方法被自动调用,干活！！！ pool-1-thread-6
call()方法被自动调用,干活！！！ pool-1-thread-2
call()方法被自动调用,干活！！！ pool-1-thread-5
call()方法被自动调用，任务的结果是：0 pool-1-thread-1
call()方法被自动调用，任务的结果是：1 pool-1-thread-2
call()方法被自动调用,干活！！！ pool-1-thread-2
call()方法被自动调用,干活！！！ pool-1-thread-6
call()方法被自动调用,干活！！！ pool-1-thread-4
call()方法被自动调用，任务的结果是：2 pool-1-thread-3
call()方法被自动调用,干活！！！ pool-1-thread-3
call()方法被自动调用，任务的结果是：3 pool-1-thread-4
call()方法被自动调用，任务的结果是：4 pool-1-thread-5
call()方法被自动调用，任务的结果是：5 pool-1-thread-6
call()方法被自动调用，任务的结果是：6 pool-1-thread-2
call()方法被自动调用，任务的结果是：7 pool-1-thread-6
call()方法被自动调用，任务的结果是：8 pool-1-thread-4
call()方法被自动调用，任务的结果是：9 pool-1-thread-3

几种不同的ExecutorService线程池对象

1.newCachedThreadPool()      -缓存型池子，先查看池中有没有以前建立的线程，如果有，就reuse.如果没有，就建一个新的线程加入池中
-缓存型池子通常用于执行一些生存期很短的异步型任务
 因此在一些面向连接的daemon型SERVER中用得不多。
-能reuse的线程，必须是timeout IDLE内的池中线程，缺省timeout是60s,超过这个IDLE时长，线程实例将被终止及移出池。
  注意，放入CachedThreadPool的线程不必担心其结束，超过TIMEOUT不活动，其会自动被终止。
2. newFixedThreadPool     -newFixedThreadPool与cacheThreadPool差不多，也是能reuse就用，但不能随时建新的线程
-其独特之处:任意时间点，最多只能有固定数目的活动线程存在，此时如果有新的线程要建立，只能放在另外的队列中等待，直到当前的线程中某个线程终止直接被移出池子
-和cacheThreadPool不同，FixedThreadPool没有IDLE机制（可能也有，但既然文档没提，肯定非常长，类似依赖上层的TCP或UDP IDLE机制之类的），所以FixedThreadPool多数针对一些很稳定很固定的正规并发线程，多用于服务器
-从方法的源代码看，cache池和fixed 池调用的是同一个底层池，只不过参数不同:
fixed池线程数固定，并且是0秒IDLE（无IDLE）
cache池线程数支持0-Integer.MAX_VALUE(显然完全没考虑主机的资源承受能力），60秒IDLE  
3.ScheduledThreadPool     -调度型线程池
-这个池子里的线程可以按schedule依次delay执行，或周期执行
4.SingleThreadExecutor     -单例线程，任意时间池中只能有一个线程
-用的是和cache池和fixed池相同的底层池，但线程数目是1-1,0秒IDLE（无IDLE）

上面四种线程池，都使用Executor的缺省线程工厂建立线程，也可单独定义自己的线程工厂
下面是缺省线程工厂代码:

    static class DefaultThreadFactory implements ThreadFactory {
        static final AtomicInteger poolNumber = new AtomicInteger(1);
        final ThreadGroup group;
        final AtomicInteger threadNumber = new AtomicInteger(1);
        final String namePrefix;
        DefaultThreadFactory() {
            SecurityManager s = System.getSecurityManager();
            group = (s != null)? s.getThreadGroup() :Thread.currentThread().getThreadGroup();
          
            namePrefix = "pool-" + poolNumber.getAndIncrement() + "-thread-";
        }
        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r,namePrefix + threadNumber.getAndIncrement(),0);
            if (t.isDaemon())
                t.setDaemon(false);
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }
    }

也可自己定义ThreadFactory，加入建立池的参数中

 public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {


Executor的execute()方法

execute() 方法将Runnable实例加入pool中,并进行一些pool size计算和优先级处理
execute() 方法本身在Executor接口中定义,有多个实现类都定义了不同的execute()方法
如ThreadPoolExecutor类（cache,fiexed,single三种池子都是调用它）的execute方法如下：

    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
            if (runState == RUNNING && workQueue.offer(command)) {
                if (runState != RUNNING || poolSize == 0)
                    ensureQueuedTaskHandled(command);
            }
            else if (!addIfUnderMaximumPoolSize(command))
                reject(command); // is shutdown or saturated
        }
    }

Fragment的使用我们可以分为：使用支持库，创建一个Fragment，创建一个动态UI，多个Fragment之间的通信。文章补充了关于FragmentManager findFragmentById 返回nul如何解决。

Android Fragment的使用

1、使用支持库

如果您的应用需要运行在3.0及以上的版本，可以忽略这部分内容。

如果您的应用使用在3.0以下、1.6及以上的版本，需要使用支持库来构建。

使用支持库的步骤：

1.使用SDK下的SDK Manager工具下载Android Support Package

2. 在您的Android工程的顶级目录下创建一个libs目录

3. 找到您的SDK下的/extras/android/support/v4/android-support-v4.jar，并且拷贝到您的项目的libs下，选中这个jar包 → 右键 → Build Path → Add to Build Path

4.在您的项目的Manifest.xml文件的标签下添加：

android:targetSdkVersion="8"/>

其中targetSdkVersion是您的软件最小支持的版本

5.如果您的项目支持3.0以下的版本，请导入如下的包：android.support.v4.*;

在使用Fragment的Activity请继承FragmentActivity而不是Activity。如果您的系统是3.0或以上版本，同样需要导入类似的包，但是可以使用普通的Activity。

2、创建一个Fragment

Fragment支持在不同的Activity中使用并且可以处理自己的输入事件以及生命周期方法等。可以看做是一个子Activity。

创建一个Fragment

创建一个Fragment和创建一个Activity很类似，继承Fragment类，重写生命周期方法，主要的不同之处就是需要重写一个onCreateView()方法来返回这个Fragment的布局。例子：

Fragment的生命周期方法依赖于Activity的生命周期，例如一个Activity的onPause()的生命周期方法被调用的时候这个Activity中的所有的Fragment的onPause()方法也将被调用。

更多的内容请参照类Fragment。

使用XML添加Fragment到Activity

尽管Fragment可以被多个Activity重用，但是您也必须把Fragment关联到一个FragmentActivity上。可以使用XML布局文件的方式来实现这种关联。

说明：上面的所说的FragmentActivity适用在API在3.0以下的版本，3.0及以上的版本可以使用普通的Activity。

例子：

上面使用fragment标签，android:name=””指定一个添加到xml中的Fragment。对于创建不同的屏幕尺寸布局的更多信息，请阅读支持不同的屏幕尺寸。

当您添加一个片段一个活动布局定义的布局XML文件中的片段，你不能删除在运行时的片段。如果您打算在用户交互和交换片段，你必须添加的活性片段的活动时第一次启动。

3、构建一个灵活的UI

FragmentManager提供了对Activity运行时的Fragment的添加、删除、替换的操作。

在Activity运行期间你可以添加Fragment而不是在XML布局文件中进行定义。如果你打算在Activity中改变Fragment的生命过程。

如果要执行添加、删除、修改的操作，你必须通过FragmentManager的对象获得一个FragmentTransaction对象，通过它的API来执行这些操作。

添加一个Fragment到一个Activity，必须把这个Fragment添加到一个容器视图中。例子：

在Activity中你可以通过getFragmentManager()来获得Fragment对象，然后通过FragmentManager对象的beginFragmentTransaction()方法来获得FragmentTransaction对象。通过它的add()方法来添加一个Fragment到当前的Activity中。

一个FragmentTransaction对象可以执行多个增删修的方法，如果你想把这些修改提交到Activity上，必须在最后调用一下这个对象的commit()方法。例子：

由于不是定义在XML布局中的，所有可以转型删除和修改的操作。

如果替换或者删除一个Fragment然后让用户可以导航到上一个Fragment，你必须在调用commit()方法之前调用addToBackStack()方法添加到回退栈。如果你把这个Fragment添加到了回退栈，在提交之后这个Fragment是会被Stop而不是Destroyed。如果用户导航到这个Fragment，这个Fragment会被Restart而不是重新创建。如果你没有把它添加到回退栈，则在删除或者替换的时候它将被Destroyed。例子：

4、与其他Fragment的交互

两个单独的Fragment之间是不应该进行通信的。应该使用他们所存在的Activity作为沟通的纽带。

为了实现两个Fragment的交互，您可以在Fragment中定义一个接口，然后再这个接口中定义一个方法，在Fragment的onAttach()方法中调用这个接口中的方法。然后让Activity实现这个方法来完成Activity和Fragment之间的通信。例子：

定义接口并调用方法：

实现接口，在这个方法中可以进行与其他Fragment的数据的交互：

可以通过FragmentManager的findFragmentById()来查找一个Fragment。

FragmentManager findFragmentById返回nul解决办法

看Fragment的两种生成方式

一.用xml标签生成

在fragment的宿主activity中添加xml标签

<fragment
        android:id="@+id/fragment_newsContent"
        android:name="com.firstcode.section4_news.NewsContentFragment"
        android:layout_width="match_parent"
        android:layout_height="match_parent"/>

name为你创建的fragment类

这种方法在activity创建时fragment已经生成了

在Activity中获取fragment实例的操作：

NewsContentFragment fragment = (NewsContentFragment) getFragmentManager().findFragmentById(R.id.fragment_newsContent);

 

二、用java代码动态生成

在fragment的宿主activity的视图文件中添加FrameLayout进行占位

<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/fragmentContainer"/>

在Activity中生成fragment的操作

FragmentManager fm = getFragmentManager();
fm.beginTransaction()
    .add(R.id.fragmentContainer,“你创建的fragment类实例”)
    .commit();

 

问题分析：

    我在使用用FragmentManager.findFragmentById 返回nul的问题就在这，我是通过第二种方式来生成fragment的，也就是说在findFragmentById的实参

    我填的是FrameLayout的Id，而非fragment的Id 所以会返回null

解决方案：

    　　1.如果是静态生成fragment，获取fragment实例用getFragmentManager().findFragmentById
    　　2.如果是java代码动态生成fragment，获取fragment实例直接new 一个就好了 没必要用getFragmentManager().findFragmentById
    　　3.注意xml文件中的标签FrameLayout与fragment

还有个问题，我也是这样解决的 在fragment视图里给textview添加文字

Caused by: java.lang.NullPointerException: Attempt to invoke virtual method 'void android.widget.TextView.setText(java.lang.CharSequence)' on a null object reference

原因是通过java代码生成的fragment add里的Id参数填的是fragment的id 所以fragment的视图没有生成

理解两种fragment生成方式最好的文档莫过于google官方的Android Training下面是中文翻译

使用xml标签添加fragment
使用java代码动态添加fragment

本文章给各位介绍是一篇Android开发之自定义Spinner的例子，因为安卓自带的spinner不适合设计要求了，所以需要自己做一个，下面看例子。

最近在做的项目中有很多下拉框，为了实现方便就用了Android 自带的Spinner,但是自带的Spinner的样式又不符合要求，就学习了一下自定义Spinner。下面是整个步骤：

1.准备好图片

2.style中定义

<!-- spinner -->
<style name="spinner_style">
 <item name="android:background">@drawable/spinner</item>
<item name="android:paddingLeft">5dip</item>
 
3.调用

<Spinner
android:id="@+id/field_item_spinner_content"
style="@style/spinner_style"
android:layout_width="fill_parent"
android:layout_height="wrap_content"/>

4.在layout中定义simple_spinner_item.xml

<?xml version="1.0" encoding="utf-8"?>
<CheckedTextView xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@android:id/text1"
android:paddingLeft="5dip"
android:paddingRight="5dip"
android:gravity="center_vertical"
android:textColor="#808080"
android:singleLine="true"
android:layout_width="fill_parent"
android:layout_height="wrap_content" />

5.java代码

ArrayAdapter<String> adapter = new ArrayAdapter<String>(mContext,R.layout.simple_spinner_item);
String level[] = getResources().getStringArray(R.array.affair_level);//资源文件
for (int i = 0; i < level.length; i++) {
    adapter.add(level[i]);
      }
adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
spinner.setAdapter(adapter);

效果图：

 

android应用开发中，加载显示大图片，我们可以使用BitmapFactory.Options，本文我们来讲讲BitmapFactory.Options的使用及BitmapFactory.Options避免 内存溢出 OutOfMemoryError的优化方法。

android中BitmapFactory.Options的使用是在加载图片时,就从图片的加载和使用说起

怎样获取图片的大小？
首先我们把这个图片转成Bitmap，然后再利用Bitmap的getWidth()和getHeight()方法就可以取到图片的宽高了。
新问题又来了，在通过BitmapFactory.decodeFile(String path)方法将突破转成Bitmap时，遇到大一些的图片，我们经常会遇到OOM(Out Of Memory)的问题。怎么避免它呢？
这就用到了我们上面提到的BitmapFactory.Options这个类。
BitmapFactory.Options这个类，有一个字段叫做 inJustDecodeBounds 。SDK中对这个成员的说明是这样的：
If set to true, the decoder will return null (no bitmap), but the out…
也就是说，如果我们把它设为true，那么BitmapFactory.decodeFile(String path, Options opt)并不会真的返回一个Bitmap给你，它仅仅会把它的宽，高取回来给你，这样就不会占用太多的内存，也就不会那么频繁的发生OOM了。
示例代码如下：

BitmapFactory.Options options = new BitmapFactory.Options();

options.inJustDecodeBounds = true;

Bitmap bmp = BitmapFactory.decodeFile(path, options);/* 这里返回的bmp是null */

BitmapFactory.Options options = new BitmapFactory.Options();

options.inJustDecodeBounds = true;

Bitmap bmp = BitmapFactory.decodeFile(path, options);/* 这里返回的bmp是null */

这段代码之后，options.outWidth 和 options.outHeight就是我们想要的宽和高了。
有了宽，高的信息，我们怎样在图片不变形的情况下获取到图片指定大小的缩略图呢？
比如我们需要在图片不变形的前提下得到宽度为200的缩略图。
那么我们需要先计算一下缩放之后，图片的高度是多少 ,代码如下

int height = options.outHeight * 200 / options.outWidth;

options.outWidth = 200;

options.outHeight = height;

options.inJustDecodeBounds = false;

Bitmap bmp = BitmapFactory.decodeFile(path, options);

image.setImageBitmap(bmp);

int height = options.outHeight * 200 / options.outWidth;

options.outWidth = 200；
options.outHeight = height;
options.inJustDecodeBounds = false;
Bitmap bmp = BitmapFactory.decodeFile(path, options);
image.setImageBitmap(bmp);


这样虽然我们可以得到我们期望大小的ImageView
但是在执行BitmapFactory.decodeFile(path, options);时，并没有节约内存。要想节约内存，还需要用到BitmapFactory.Options这个类里的 inSampleSize 这个成员变量。
我们可以根据图片实际的宽高和我们期望的宽高来计算得到这个值。

options.inSampleSize = options.outWidth / 200;

/*图片长宽方向缩小倍数*

options.inSampleSize = options.outWidth / 200;

/*图片长宽方向缩小倍数*/

另外，为了节约内存我们还可以使用下面的几个字段：

options.inDither=false;/*不进行图片抖动处理*/
options.inPreferredConfig=null; /*设置让解码器以最佳方式解码*/
/* 下面两个字段需要组合使用 */
options.inPurgeable = true;
options.inInputShareable = true;



android的BitmapFactory.Options避免内存溢出OOM的优化方法

尽量不要使用setImageBitmap或setImageResource或BitmapFactory.decodeResource来设置一张大图，
因为这些函数在完成decode后，最终都是通过java层的createBitmap来完成的，需要消耗更多内存。

因此，改用先通过BitmapFactory.decodeStream方法，创建出一个bitmap，再将其设为ImageView的 source，
decodeStream最大的秘密在于其直接调用JNI>>nativeDecodeAsset()来完成decode，
无需再使用java层的createBitmap，从而节省了java层的空间。
如果在读取时加上图片的Config参数，可以跟有效减少加载的内存，从而跟有效阻止抛out of Memory异常
另外，decodeStream直接拿的图片来读取字节码了， 不会根据机器的各种分辨率来自动适应，
使用了decodeStream之后，需要在hdpi和mdpi，ldpi中配置相应的图片资源，
否则在不同分辨率机器上都是同样大小（像素点数量），显示出来的大小就不对了。

另外，以下方式也大有帮助：
1. InputStream is = this.getResources().openRawResource(R.drawable.pic1);
     BitmapFactory.Options options=new BitmapFactory.Options();
     options.inJustDecodeBounds = false;
     options.inSampleSize = 10;   //width，hight设为原来的十分一
     Bitmap btp =BitmapFactory.decodeStream(is,null,options);
2. if(!bmp.isRecycle() ){
         bmp.recycle()   //回收图片所占的内存
         system.gc()  //提醒系统及时回收
}

以下奉上一个方法：

Java代码

/**
 * 以最省内存的方式读取本地资源的图片
 * @param context
 * @param resId
 * @return
 */  
 public static Bitmap readBitMap(Context context, int resId){  
     BitmapFactory.Options opt = new BitmapFactory.Options();  
     opt.inPreferredConfig = Bitmap.Config.RGB_565;   
     opt.inPurgeable = true;  
     opt.inInputShareable = true;  
     //获取资源图片  
     InputStream is = context.getResources().openRawResource(resId);  
     return BitmapFactory.decodeStream(is,null,opt);  
 }

 

优化Dalvik虚拟机的堆内存分配

对 于Android平台来说，其托管层使用的Dalvik JavaVM从目前的表现来看还有很多地方可以优化处理，比如我们在开发一些大型游戏或耗资源的应用中可能考虑手动干涉GC处理，使用 dalvik.system.VMRuntime类提供的setTargetHeapUtilization方法可以增强程序堆内存的处理效率。当然具体 原理我们可以参考开源工程，这里我们仅说下使用方法:   private final static floatTARGET_HEAP_UTILIZATION = 0.75f; 在程序onCreate时就可以调用 VMRuntime.getRuntime().setTargetHeapUtilization(TARGET_HEAP_UTILIZATION); 即可。

介绍一下图片占用进程的内存算法吧。
android中处理图片的基础类是Bitmap，顾名思义，就是位图。占用内存的算法如下：
图片的width*height*Config。
如果Config设置为ARGB_8888，那么上面的Config就是4。一张480*320的图片占用的内存就是480*320*4 byte。
前面有人说了一下8M的概念，其实是在默认情况下android进程的内存占用量为16M，因为Bitmap他除了java中持有数据外，底层C++的 skia图形库还会持有一个SKBitmap对象，因此一般图片占用内存推荐大小应该不超过8M。这个可以调整，编译源代码时可以设置参数。