进程与线程

进程
    系统运行程序的基本单位
    有独立的内存空间和系统资源
线程
    进程中执行运算的最小单位
    处理机分配给线程，即真正在处理机上运行的是线程

线程

创建线程的两种传统方式
    继承Thread类
        MyThread thread = new MyThread();
        thread.start();//启动线程
    实现Runnable接口
        MyRunnable runnable = new MyRunnable();
        new Thread(runnable).start();   
API
    Thread 线程类
        getName()
            获得当前线程的名称
        currentThread()
            获得当前线程
        sleep()
            让线程的睡眠指定的时间 
多线程会提高程序的运行效率吗？
    不会，性能会降低。
为什么多线程下载会速度快？
    其实是在抢服务器的带宽。

创建定时器

定时器
    1.Timer类与TimerTask类

//5秒钟后调度执行任务
//只执行一次
//相同一个定时器只能用一次，否则会报错
Timer timer = new Timer();
timer.schedule(new TimerTask() {
    @Override
    public void run() {
        //任务
    }
}, 5*1000);

//5秒钟后调度执行任务，以后每2秒再执行一次
Timer timer = new Timer();
//5秒钟后调度任务
timer.schedule(new TimerTask() {
    @Override
    public void run() {
        //任务
    }
}, 5*1000,2*1000);  

线程同步synchronized

1.同步代码块
    synchronized (this) {
        
    }
    
2.同步方法
    public synchronized void output(){}
    锁对象是当前Java类的字节码对象 Test.class

线程通信-wait/notify

生产者与消费者

Lock&Condition

Lock比传统线程模型中的synchronized方式更加面向对象，与生活中的锁类似。
锁本身也应该是一个对象。两个线程执行的代码片段要实现同步互斥的效果，他们必须
用同一个Lock对象，锁是代表要操作的资源的类的内部方法中，而不是线程线程代码中。

线程范围内的共享数据

//有问题，打印的数据不对
    public class ThreadShareData1 {
        private static int data = 0;
        static class A{
            public void get(){
                System.out.println(Thread.currentThread().getName()+" a:"+data);
            }
        }
        static class B{
            public void get(){
                System.out.println(Thread.currentThread().getName()+" b:"+data);
            }
        }
        public static void main(String[] args) {
            for(int i = 0;i<5;i++){
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        data = new Random().nextInt(100);
                        System.out.println(Thread.currentThread().getName()+" input data :"+data);
                        new A().get();
                        new B().get();
                    }
                }).start();
            }
        }
    }
//在某一个线程内，有独立的数据
    public class ThreadShareData {
        private static Map<Thread,Integer> threadData = new HashMap<Thread,Integer>();
        static class A{
            public void get(){
                int data = threadData.get(Thread.currentThread());
                System.out.println(Thread.currentThread().getName()+" a:"+data);
            }
        }
        static class B{
            public void get(){
                int data = threadData.get(Thread.currentThread());
                System.out.println(Thread.currentThread().getName()+" b:"+data);
            }
        }
        public static void main(String[] args) {
            for(int i = 0;i<5;i++){
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        int data = new Random().nextInt(100);
                        System.out.println(Thread.currentThread().getName()+" input data :"+data);
                        threadData.put(Thread.currentThread(), data);
                        new A().get();
                        new B().get();
                    }
                }).start();
            }
        }
    }
//Java提供的类，解决线程数据共享问题
//在某一个线程内，有独立的数据
//总结:一个ThreadLocal只能代表一个变量，所以其中只能放一个数据。如果你有两个变量，只能创建两个ThreadLocal对象。
//也可以把一堆数据封装到一个对象中。
    public class ThreadShareData {
        //相当于往map中放整数
        private static ThreadLocal<Integer> tl = new ThreadLocal<Integer>();
        static class A{
            public void get(){
                int data = tl.get();
                System.out.println(Thread.currentThread().getName()+" a:"+data);
            }
        }
        static class B{
            public void get(){
                int data = tl.get();
                System.out.println(Thread.currentThread().getName()+" b:"+data);
            }
        }
        public static void main(String[] args) {
            for(int i = 0;i<5;i++){
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        int data = new Random().nextInt(100);
                        System.out.println(Thread.currentThread().getName()+" input data :"+data);
                        tl.set(data);
                        new A().get();
                        new B().get();
                    }
                }).start();
            }
        }
    }
//在某一个线程内，有独立的数据，封装多个数据
    class User{
        private int id;
        private String name;
        public int getId() {
            return id;
        }
        public void setId(int id) {
            this.id = id;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
    }
    public class ThreadShareData {
        //相当于往map中放整数
        private static ThreadLocal<User> tl = new ThreadLocal<User>();
        static class A{
            public void get(){
                User user = tl.get();
                System.out.println(Thread.currentThread().getName()+" a:"+user.getName());
            }
        }
        static class B{
            public void get(){
                User user = tl.get();
                System.out.println(Thread.currentThread().getName()+" b:"+user.getName());
            }
        }
        public static void main(String[] args) {
            for(int i = 0;i<2;i++){
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        int data = new Random().nextInt(100);
                        System.out.println(Thread.currentThread().getName()+" input data :"+data);
                        User user = new User();
                        user.setId(data);
                        user.setName("user"+data);
                        tl.set(user);
                        new A().get();
                        new B().get();
                    }
                }).start();
            }
        }
    }
优美设计
    public class Data {
        private Data(){}
        /**
         * 每个线程调用全局的ThreadLocal对象的set方法，就相当于往其内部的map对象中添加一条记录。
         * key分别是各自的线程，value是传入的值。
         * 在线程结束的时候可以调用ThreadLocal的clear方法，这样可以快速释放内存。不调用也可以，在线程结束的时候自动释放。
         * */
        private static ThreadLocal<Data> map = new ThreadLocal<Data>();
        public static Data getInstance(){//这里不需要synchronized
            Data data = map.get();
            if(data == null){
                data = new Data();
                map.set(data);
            }
            return data;
        }
        private int id;
        private String name;
        public int getId() {
            return id;
        }
        public void setId(int id) {
            this.id = id;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
    }
    public class ThreadShareData {
        //相当于往map中放整数
        static class A{
            public void get(){
                System.out.println(Thread.currentThread().getName()+" a:"+Data.getInstance().getId());
            }
        }
        static class B{
            public void get(){
                System.out.println(Thread.currentThread().getName()+" b:"+Data.getInstance().getId());
            }
        }
        public static void main(String[] args) {
            for(int i = 0;i<2;i++){
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        int data = new Random().nextInt(100);
                        System.out.println(Thread.currentThread().getName()+" input data :"+data);
                        Data.getInstance().setId(data);
                        new A().get();
                        new B().get();
                    }
                }).start();
            }
        }
    }
多个线程访问共享对象和数据的方式
    可以使用同一个Runnable对象，这样就可以操作同一个数据了