JAVA多线程笔记总结.

开发安卓的过程中，常常会用到java的一些知识，有时候回忆起却有点模糊，索性把它写成博客，这样可以让自己对知识有更深入的理解，另一方面，以后也可以方便查看

看威哥的视频总结：

首先从以下几个方面对线程进行分析：

1、进程与线程

首先要分清进程与线程的概念：

进程是一个具有一定独立功能的程序,一个实体,每一个进程都有它自己的地址空间。

线程实际上是在进程基础之上的进一步划分,一个进程启动之后,里面的若干程序又可以划分成若干个线程。

它是进程中的一个执行路径,共享一个内存空间,线程之间可以自由切换,并发执行,一个进程最少有一个

线程(单线程程序) 

线程实现的两种方式：

在Java中如果要想实现多线程的操作,有两种实现方法:

(1)一种是继承Thread类

(2)另外一种是实现Runnable接口 （常用）在安卓开发中，常常使用匿名内部类：new Thread(Runnable target).start或new Thread(){.run方法..}

package com.vince;


/**
 * 进程：一个具有独立内存空间的执行程序
 * 线程：线程是进程中的其中一条执行路径（多条就是多线程），每个进程最少有一个线程
 * 同一个进程中的多个线程共享同一个内存空间
 * 实现多线程的两种方式：
 * 1、继承Thread类
 * 2、实现Runnable接口(推荐)
 * @author vince
 *
 */
public class ThreadDemo {


public static void main(String[] args) {



//使用
//创建一个线程对象
MyThread t1 = new MyThread();
t1.setPriority(Thread.MAX_PRIORITY);//设置抢占CPU执行时间的优先级（注意，只是机率大而已）
t1.setDaemon(true);//把t1设置为守护线程
//
// t1.run();//直接调用不是启动线程，而是在本线程中执行方法
t1.start();//线程已准备就绪，等待CPU的调度


MyRunnable r = new MyRunnable();
Thread t2 = new Thread(r);
System.out.println("isAlive="+t2.isAlive());
t2.start();
System.out.println("isAlive="+t2.isAlive());

for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+"-"+i);
try {
Thread.sleep(500);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
if(i==6){
// try {
// t1.join();//等待t1线程执行完毕
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
Thread.yield();//让出当次CPU的执行时间
}
}
}

//继承Thread类实现线程
static class MyThread extends Thread{
@Override
public void run() {
//在此方法中编写线程要执行的工作
for (int i = 0; i < 10; i++) {
try {
//在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），
//此操作受到系统计时器和调度程序精度和准确性的影响。该线程不丢失任何监视器的所属权。
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"-"+System.currentTimeMillis()+"-"+i);
}
}
}
//实现Runnable接口的方式实现线程
static class MyRunnable implements Runnable{
@Override
public void run() {
//在此方法中编写线程要执行的工作
for (int i = 0; i < 10; i++) {
try {
//在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），
//此操作受到系统计时器和调度程序精度和准确性的影响。该线程不丢失任何监视器的所属权。
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"-"+System.currentTimeMillis()+"-"+i);
}
}
}


}

2、线程的操作方法

可以直接查阅相关资料文档，几个常用的sleep,join等等。。。

3.线程同步

因为有时候往往多个线程处理同一个资源时，就容易出错，因此才需要同步，同步有三个方法

1.同步代码块

2.同步方法

3.Lock

当编写 synchronized 块时,有几个简单的准则可以遵循,这些准则在避免死锁和性能危险的风险方面大有帮助:

3、同步准则

(1)使代码块保持简短。把不随线程变化的预处理和后处理移出synchronized 块。

(2)不要阻塞。如InputStream.read()。

(3)在持有锁的时候,不要对其它对象调用方法。

具体事例如下： 

package com.vince;


import java.util.concurrent.locks.ReentrantLock;


/**
 * 线程同步 1、同步代码块 2、同步方法 3、Lock
 * 同步会牺牲性能来换取安全
 * @author vince
 *
 */
public class ThreadDemo2 {


public static void main(String[] args) {
MyThread my = new MyThread();
Thread t1 = new Thread(my);
Thread t2 = new Thread(my);


t1.start();
t2.start();
}


static class MyThread implements Runnable {
private int flag;//
private Object obj = new Object();


@Override
public void run() {
//同步代码块
synchronized (obj) {
for (int i = 0; i < 5; i++) {
flag = 0;
System.out.println("开始打饭-" + flag);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
flag = 1;
System.out.println("饭已打完-" + flag);
}
}
}

//同步方法:同步的锁对象是当前对象
public synchronized void eat(){
for (int i = 0; i < 5; i++) {
flag = 0;
System.out.println("开始打饭-" + flag);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
flag = 1;
System.out.println("饭已打完-" + flag);
}
}
public synchronized void method2(){
System.out.println("method2...");
}
//互斥锁
private final ReentrantLock lock = new ReentrantLock();
public void eat2(){
lock.lock();//上锁

for (int i = 0; i < 5; i++) {
flag = 0;
System.out.println("开始打饭-" + flag);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
flag = 1;
System.out.println("饭已打完-" + flag);
}

lock.unlock();//解锁


}
}
}

4.中断线程，往往可以自己定义boolean，来加以控制判断

package com.vince;


//中断线程：自定义标记
public class ThreadDemo3 {


public static void main(String[] args) throws InterruptedException {


MyThread my = new MyThread();
Thread t1 = new Thread(my);
t1.start();
// t1.stop();//停止
for (int i = 0; i < 10; i++) {
Thread.sleep(500);

}
my.flag = false;

}


static class MyThread implements Runnable{

public boolean flag;
public MyThread(){
flag = true;
}
@Override
public void run() {
int i = 0;
while(flag) {
System.out.println("i="+i);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
i++;
if(i==100)break;//退出循环
}
}
}
}

4、死锁

同步多了就容易死锁，就像堵车一样互不让路，这样就一直堵在那里。

具体实例如下

package com.vince;
/**
 * 线程死锁
 * @author vince
 *
 */
public class DeadThreadDemo {


public static void main(String[] args) {
new DeadThread();
}


}


//顾客
class Customer{
public synchronized void say(Waiter w){
System.out.println("顾客说：先吃饭再买单！");
w.doService();
}

public synchronized void doService(){
System.out.println("同意了,买完单再吃饭！");
}
}
//服务员
class Waiter{
public synchronized void say(Customer c){
System.out.println("服务员说：先买单再吃饭！");
c.doService();
}
public synchronized void doService(){
System.out.println("同意了，吃完饭再买单！");
}
}




//死锁线程
class DeadThread implements Runnable{
Customer c = new Customer();
Waiter w = new Waiter();
public DeadThread(){
new Thread(this).start();
w.say(c);
}
@Override
public void run() {
c.say(w);
}
}

5、生产者与消费者应用案例（经典案例）

package com.vince;


/**
 * 生产者与消费者案例
 * @author vince
 *
 */
public class ThreadDemo4 {


public static void main(String[] args) {

Food food = new Food();
Producter p = new Producter(food);
Customers c = new Customers(food);
Thread t1  = new Thread(p);
Thread t2 = new Thread(c);
t1.start();
t2.start();
}
}
//生产者
class Producter implements Runnable{
private Food food;
public Producter(Food food){
this.food = food;
}
@Override
public void run() {
for(int i=0;i<50;i++){
if(i%2==0){
// System.out.println("");
// food.setName("银耳莲子汤");
// try {
// Thread.sleep(500);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// food.setEfficasy("功效：美容养颜");
food.set("银耳莲子汤", "功效：美容养颜");
}else{
// food.setName("糖醋里脊");
// try {
// Thread.sleep(500);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// food.setEfficasy("功效：酸甜可口，可增肥");
food.set("糖醋里脊", "功效：酸甜可口，可增肥");
}
}
}
}


//消息者
class Customers implements Runnable{
private Food food;
public Customers(Food food){
this.food = food;
}
@Override
public void run() {
for (int i = 0; i < 50; i++) {
// try {
// Thread.sleep(500);
// } catch (InterruptedException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
// System.out.println(food.getName()+"->"+food.getEfficasy());
food.get();
}
}
}


//消费的对象（数据）
class Food{
private String name;//菜名
private String efficasy;//功效

private boolean flag = true;//true表示可以生产不能消费，false表示可以消费不能生产

public Food() {
super();
}
public Food(String name, String efficasy) {
super();
this.name = name;
this.efficasy = efficasy;
}

//生产产品
public synchronized void set(String name,String efficasy){
//表示不能生产
if(!flag){
try {
this.wait();//当前线程进入等待状态，让出CPU，并释放该监视器上的锁
} catch (InterruptedException e) {
e.printStackTrace();
}
}


this.setName(name);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setEfficasy(efficasy);
flag = false;//表示不能再生产
this.notify();//唤醒该监视器上的其它一个线程
}


public synchronized void get(){

if(flag){
try {
this.wait();//
} catch (InterruptedException e) {
e.printStackTrace();
}
}

try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(this.getName()+"->"+this.getEfficasy());
flag = true;//表示不能再取
this.notify();//唤醒该监视器上的其它一个线程
}


public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getEfficasy() {
return efficasy;
}
public void setEfficasy(String efficasy) {
this.efficasy = efficasy;
}
}

6、线程池 

package com.vince;


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


public class ExecutorDemo {


public static void main(String[] args) {
//创建一个单线程的执行器
// ExecutorService es = Executors.newSingleThreadExecutor();
//创建一个固定数量的线程执行器
// ExecutorService es = Executors.newFixedThreadPool(3);
//创建一个可缓存线程的执行器（60秒空间将被回收）
ExecutorService es = Executors.newCachedThreadPool();
// ExecutorService es = Executors.newScheduledThreadPool(3);
es.execute(new DownloadThread());
es.execute(new DownloadThread());
es.execute(new DownloadThread());
es.execute(new DownloadThread());

}


static class DownloadThread implements Runnable{
@Override
public void run() {

for (int i = 0; i <= 10; i++) {
System.out.println(Thread.currentThread().getName()+"已下载"+(i*10)+"%");
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}

}
}


}