7 月 | 2014 | 海纳百川的博客

1, 线程简介（略）

2, 线程锁

说明：

2.1) 两个主要特性：互斥和可见性

互斥：即一次只允许一个线程持有某个特定的锁，可利用改特性实现对共享数据的协调访问，这样，一次就只有个一个线程使用该共享数据。

可见性：即线程在释放锁之后对共享变量的修改对之后获取该锁的线程是可见的

2.2) 使用synchronized或volatile，

synchronized：

public class Account {
	private float totalMoney;

	public synchronized void saveMoney(float money) {
    		this.totalMoney += money;
	}

	public synchronized void takeMoney(float money) {
		    if(this.totalMoney - money >= 0) {
			        this.totalMoney -= money;
		    }
	}

}

说明：对存钱，取钱方法进行加锁：当有一个线程A调用存钱时，其他的存钱线程必须被阻塞，待A结束后，其他线程才能继续，即有且只能有一个线程调用存钱方法，取钱操作亦如此。

volatile:

说明：volatile具有synchronized的可见性特性，但不具备互斥性

使用条件：介于volatile不预备原子性，所以在多线程写操作较频繁时，不适用使用volatile修饰变量，因为volatile的可见性（对共享变量的修改可直接被用于其他线程），所以在写操作较少，读操作较多的时候，可以考虑使用volatile

使用场景：比如有某个变量V，存储的是从数据库读取的配置参数，其他线程要读取这个配置参数进行不同的操作，另外有一个线程是每隔一段时间从数据库读取配置信息赋予V, 这个变量V可以声明为volatile,确保每次读取最新配置后，其它线程使用的都是最新的。

3，死锁

说明：最常见的死锁形式是当线程1持有对象A上的锁，而且正在等待B上的锁释放，线程2持有对象B上的锁，但在等待A上的锁释放，这样线程1和线程2就会一直处于等待状态，因为两者都不会主动释放自己的锁，那么就称他们被死锁了。

例子：

public class Deadlock extends Thread{

    private static Object lock1 = new Object();
    private static Object lock2 = new Object();

    private int mentod_flag = 1;

    public Deadlock(int flag) {
        this.mentod_flag = flag;
    }

    void a () {
        synchronized(lock1) {
            System.out.println("a(), lock1 is synchronized");
            try {
                Thread.sleep(1000);
            }catch (Exception e) {
                e.printStackTrace();
            }
            synchronized(lock2) {
                System.out.println("a(), lock2 is synchronized");
                System.out.println("a(), lock1: "+lock1+" | lock2: "+ lock2);
            }
        }
    }

    void b () {
        synchronized(lock2) {
            System.out.println("b(), lock2 is synchronized");
            try {
                Thread.sleep(1000);
            }catch (Exception e) {
                e.printStackTrace();
            }
            synchronized(lock1) {
                System.out.println("b(), lock1 is synchronized");
                System.out.println("b(), lock1: "+lock1+" | lock2: "+ lock2);
            }
        }
    }

    public void run() {
        if(this.mentod_flag == 1) {
            this.a();
        }else {
            this.b();
        }
    }

    public static void main(String[] args) {
        new Deadlock(1).start();
        new Deadlock(2).start();
    }
}

4，线程调度

join(), wait(), notify(), notifyAll();

4.1) wait()和notify(), notifyAll()协同使用

Object类定义了wait(), notify(), notifyAll()方法；要执行这些方法，必须拥有相关对象的锁

wait()会让调用的线程休眠，直到用Thread.interrupt(), 过了等待的时间（wait(long timeout)）, 另一个线程用notify()或notifyAll()唤醒他

当对某个对象调用notify时，如果有任何线程正在通过wait()等待该对象，那么就会唤醒其中一个线程，如果调用notifyAll(), 就会唤醒所有正在等待该对象的线程。

使用场景：比较有代表性的是生产者和消费者例子：生产者线程A负责生产产品，当产品数量达到指定上限，停止生产，消费者线程B负责消费产品，但产品数量达到0时停止消费，并通知A生产产品。

例子：

public class Product {
    private Long productNo;

    public Long getProductNo() {
        return productNo;
    }

    public Product(Long productNo) {
        this.productNo = productNo;
    }

}

public class PublicResource {
    private List<Product> products = new ArrayList<Product>();

    public List<Product> getProducts() {
        return this.products;
    }

    public synchronized void add() {
        while(products.size() >= 20) {
            try {
                this.wait();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        Product p = new Product(System.currentTimeMillis());
        this.products.add(p);
        System.out.println("add product, productNo: "+p.getProductNo());
        this.notify();
    }

    public synchronized void remove() {
        while(products.size() <= 0) {
            try {
                this.wait();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        Product p = this.products.remove(0);
        System.out.println("remove product, productNo: "+p.getProductNo());
        this.notify();
    }

}

public class ProducerThread implements Runnable {
    private PublicResource _resource;

    public ProducerThread(PublicResource resource) {
        this._resource = resource;
    }

    @Override
    public void run() {
        for(int i=0;i<10;i++) {
            try {
                Thread.sleep((long)(Math.random()*1000));
            } catch (Exception e) {
                e.printStackTrace();
            }
            this._resource.add();
        }
    }

}

public class ConsumerThread implements Runnable {
    private PublicResource _resource;

    public ConsumerThread(PublicResource resource) {
        this._resource = resource;
    }

    @Override
    public void run() {
        for(int i=0;i<10;i++) {
            try {
                Thread.sleep((long)(Math.random()*1000));
            } catch (Exception e) {
                e.printStackTrace();
            }
            this._resource.remove();
        }

    }

}

public class ProductMain {

    public static void main(String[] args) throws InterruptedException {
        PublicResource resource = new PublicResource(); 
        new Thread(new ProducerThread(resource)).start();
        new Thread(new ConsumerThread(resource)).start();
        Thread.sleep(10000);
        System.out.println(resource.getProducts().size());
    }

}

4.2) join()使用

说明：当t1调用线程t2.join()时，t1将被阻塞，直到t2线程执行完为止。

可以使用t2.join(timeout) 限制t2线程的堵塞时间。

例子：

public class JoinTest {

    public static void main(String[] args) {
        Sleeper 
            xmSleeper = new Sleeper("xmSleeper",1500),
            ywSleeper = new Sleeper("ywSleeper",1500);
        Joiner
            syJoiner = new Joiner("syJoiner", xmSleeper),
            lhJoiner = new Joiner("lhJoiner", ywSleeper);
        ywSleeper.interrupt();
    }

}

class Sleeper extends Thread {
    private int duration;
    public Sleeper(String name, int sleepTime) {
        super(name);
        duration = sleepTime;
        start();
    }

    public void run() {
        try {
            sleep(duration);
        } catch (InterruptedException e) {
            System.out.println(getName()+" was interrupted. "+"isInterrupted(): "+isInterrupted());
            return;
        }

        System.out.println(getName()+" has awakened");
    }

}

class Joiner extends Thread {
    private Sleeper sleeper;

    public Joiner(String name, Sleeper sleeper) {
        super(name);
        this.sleeper = sleeper;
        start();
    }

    public void run() {
        try {
            sleeper.join();
        } catch (InterruptedException e) {
            System.out.println("Interrupted");
        }
        System.out.println(getName() + " join completed");
    }

}

4.3) yield()方法

说明：若在某个线程调用Thread.yield()，此时这个线程会让出cpu资源，留给下一个线程执行，下一个线程不确定，有可能是他自己，也有可能是另一个线程。

例子：

public class YieldTest {

    public static void main(String[] args) {
        ThreadTest1 t1 = new ThreadTest1();
        t1.start();
        ThreadTest2 t2 = new ThreadTest2();
        t2.start();
    }

    public static class ThreadTest1 extends Thread {
        public void run() {
            for(int i=0;i<10;i++) {
                System.out.println("ThreadTest1: 第"+i+"次运行");
                Thread.yield();
            }
        }
    }

    public static class ThreadTest2 extends Thread {
        public void run() {
            for(int i=0;i<10;i++) {
                System.out.println("ThreadTest2: 第"+i+"次运行");
            }
        }
    }

}
//output:
ThreadTest1: 第0次运行
ThreadTest1: 第1次运行
ThreadTest1: 第2次运行
ThreadTest2: 第0次运行
ThreadTest1: 第3次运行
ThreadTest2: 第1次运行
ThreadTest1: 第4次运行
ThreadTest2: 第2次运行
ThreadTest2: 第3次运行
ThreadTest2: 第4次运行

5. 守护线程

说明：比如我们在main方法中启动一个线程，当mian方法中所有的代码执行完成后，若此线程仍没结束，他仍会在后台运行，怎样控制当main方法运行完毕，同时此线程也结束，就要用到守护线程。

例子：

public class SimpleDaemons {

    public static void main(String[] args) throws InterruptedException {
        ThreadTest t = new ThreadTest();
        t.setDaemon(true);
        t.start();
        Thread.sleep(5000);
    }

    public static class ThreadTest extends Thread {
        public void run() {
            while(true) {
                System.out.println("ThreadTest: print something");
                try {
                    Thread.sleep(1000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

说明：当main函数休眠5秒结束后，ThreadTest也会结束。

服务（Service）是一种在后台运行，没有界面的组件，由其他组件调用开始。Android 中的服务和 Windows 中的服务是类似的东西，它运行于系统中不容易被用户发觉，可以使用它开发如监控之类的程序。

服务（Service）的实现

1. 定义类继承 Service，重写 onCreate()、 onStart(Intent intent, int startId)、 onBind(Intent intent)、 onUnbind(Intent intent)、onDestroy() 中需要的方法。

2. 在清单文件的 <application> 节点下声明 <service>。

<application
    android:icon="@drawable/ic_launcher"
    android:label="@string/app_name"
    android:theme="@style/AppTheme" >
    <activity
        android:name=".MainActivity"
        android:label="@string/title_activity_main" >
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />

            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>

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

服务不能自己运行，需要通过调用 Context.startService() 或 Context.bindService() 方法启动服务。这两个方法都可以启动 Service，但是它们的使用场合有所不同。使用 startService() 方法启用服务，访问者与服务之间没有关联，即使访问者退出了，服务仍然运行。使用 bindService() 方法启用服务，访问者与服务绑定在了一起，访问者一旦退出，服务也就终止。采用 Context.startService() 方法启动服务，只能调用 Context.stopService() 方法结束服务，服务结束时会调用 onDestroy() 方法。【注意：服务的生命周期方法都是在主线程执行，所以不能直接在服务里面做耗时操作做，如果需要做耗时操作，应该在服务里面开启子线程。】

通过 startService() 和 stopService( ) 启动和关闭服务。适用于服务和访问者之间没有交互的情况。如果服务和访问者之间需要方法调用或者传递参数，则需要使用 bindService() 和 unbindService() 方法绑定和解绑服务。

采用 Context.bindService() 方法启动服务，在服务未被创建时，系统会先调用服务的 onCreate() 方法，接着调用 onBind() 方法，这个时候访问者和服务绑定在一起。如果访问者要与服务进行通信，那么，onBind() 方法必须返回 Ibinder 对象。如果访问者退出了，系统就会先调用服务的 onUnbind() 方法，接着调用 onDestroy() 方法。如果调用 bindService() 方法前服务已经被绑定，多次调用 bindService() 方法并不会导致多次创建服务及绑定（也就是说 onCreate() 和 onBind() 方法并不会被多次调用）。如果访问者希望与正在绑定的服务解除绑定，可以调用 unbindService() 方法，调用该方法也会导致系统调用服务的 onUnbind() → onDestroy() 方法。

服务（Service）的生命周期（服务的生命周期与启动服务的方法有关）

当采用 Context.startService() 方法启动服务，生命周期如下：

onCreate() → onStart() → onDestroy()

onCreate() 该方法在服务被创建时调用，该方法只会被调用一次，无论调用多少次 startService() 或 bindService() 方法，服务也只被创建一次。onStart() 只有采用 Context.startService() 方法启动服务时才会回调该方法，该方法在服务开始运行时被调用。多次调用 startService() 方法尽管不会多次创建服务，但 onStart() 方法会被多次调用。onDestroy() 该方法在服务被终止时调用。

当采用 Context.bindService() 方法绑定服务，生命周期如下：

onCreate() → onBind() → onUnbind() → onDestroy()

onBind() 只有采用 Context.bindService() 方法启动服务时才会回调该方法。该方法在调用者与服务绑定时被调用，当调用者与服务已经绑定，多次调用 Context.bindService() 方法并不会导致该方法被多次调用。onUnbind() 只有采用 Context.bindService() 方法绑定服务后解绑服务时才会回调该方法。该方法在调用者与服务解除绑定时被调用。

如果先采用 startService() 方法启动服务,然后调用 bindService() 方法绑定到服务，再调用 unbindService() 方法解除绑定，最后调用 bindService() 方法再次绑定到服务，生命周期如下：

onCreate() → onStart() → onBind() → onUnbind()[重载后的方法需返回true] → onRebind()

海纳百川的博客

学习是一件长久的事情，每天积累一点点，不断超越自己

Monthly Archives: 7 月 2014

Java线程

Android四大组件之服务（Service）