学习笔记——JAVA线程<1>线程的基本概念和实现

线程：Thread，是进程中的一个“单一的连续的控制流程”（a single sequential flow of control）/执行路径
1.线程又被称为 轻量级进程（lightweight process）
2.Threads run at the same time ,independently of one another
3.一个进程可以拥有多个并行的（concurrent）线程
4.一个进程中的线程共享相同的内存单元/内存地址空间->可以访问相同的变量和对象，而且他们从同一堆中分配对象->通信，数据交换，同步操作（容易造成并发）
5.由于线程间的通信是在同一地址空间进行的，所以不需要额外的通信机制，这就使得通信更简便而且信息传递的速度也快

实现多线程
1>继承Thread+run()实现

package study;

/***
 * 1.创建多线程 继承Thread +重写run(线程体)
 * 2.使用线程 创建子类对象 +调用对象的star()方法 线程的启动
 * 3.
 * @author http://blog.csdn.net/thewaiting
 *
 */

public class ThreadDome extends Thread{
    @Override
    public void run() {     
        for (int i = 0; i < 10; i++) {
            System.out.println("第"+i);
        }
    }
    public static void main(String[] args) {
        ThreadDome t1= new ThreadDome();
        ThreadDome t2= new ThreadDome();
        t1.start();//不要调用run方法
        t2.start();
    }

}

2>使用Runnable创建线程
1),避免单继承的局限性
2),比喻共享资源

可以共同使用真实角色里的数据

package study;

/**
 * 静态代理 设计模式
 * 1.真实角色
 * 2.代理角色：持有真实角色的引用
 * 3.二者实现相同的接口
 * 
 * 使用Runnable创建线程
 * 1.类实现Runnable接口+重run() -->真是角色类
 *  1),创建真是角色
 *  2),创建代理角色+真实角色的引用
 *  3),调用.star()方法 启动线程
 * @author http://blog.csdn.net/thewaiting
 *
 */

public class ThreadDome implements Runnable {
    //共同使用i资源
    private int i = 5;
    @Override
    public void run() { 
        while (true) {
            if (i <= 0) {
                break;
            }
            System.out.println(Thread.currentThread().getName() + i--);
        }
    }
    public static void main(String[] args) {    
        // 1),创建真是角色
        ThreadDome td1 = new ThreadDome();
        // 2),创建代理角色+真实角色的引用
        Thread t1 = new Thread(td1, "线程 1 ");
        Thread t2 = new Thread(td1, "线程 2 ");
        // 3),调用.star()方法 启动线程
        t1.start(); 
        t2.start();
        //一步到位的方法 不过不能共享资源      
        new Thread(new ThreadDome(), "线程3 ").start();   
    }
}

3>使用Callable创建线程
1>能返回值
2>能对外声明异常

package study;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
/**
 * 使用Callable创建线程
 * @author http://blog.csdn.net/thewaiting
 */
public class ThreadDome {
    public static void main(String[] args) {
        //执行器调度器
        //创建线程
        ExecutorService ser = Executors.newFixedThreadPool(1);
        Theard1 t1 = new Theard1("线程一",100); 
        Theard1 t2 = new Theard1("线程二",20); 
        //@param 实现类对象  
        //获取值
        Future<Integer> result1 = ser.submit(t1);
        Future<Integer> result2 = ser.submit(t2);       
        try {
            Thread.sleep(2000);//执行的时间
            t1.setFlag(false);//停止线程体循环
            t2.setFlag(false);
            int num1 = result1.get();
            int num2 = result2.get();
            System.out.println("线程一"+num1);
            System.out.println("线程二"+num2);
            //停止服务
            ser.shutdown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
class Theard1 implements Callable<Integer>{
    private String name;//名称
    private long time;//延时时间
    private boolean flag = true;//
    private int num = 0;//数量的增加
    public Theard1(String name,long time) {
        this.name = name;
        this.time = time;
    }
    @Override
    public Integer call() throws Exception {    
        while(flag){
            Thread.sleep(time);//延时
            num++;
        }
        return num;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public long getTime() {
        return time;
    }
    public void setTime(long time) {
        this.time = time;
    }
    public boolean isFlag() {
        return flag;
    }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
    public int getNum() {
        return num;
    }
    public void setNum(int num) {
        this.num = num;
    }
}