[log]java的Thread基础，了解一下

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

/**
 * @author liu
 * @date 20190516
 **/

public class Start {
    public static void main(String[] args) {
        DemoA demoA = new DemoA();
        demoA.start();

        new Thread(new Demo2()).start();


        Demo3 demo3 = new Demo3();

        FutureTask<String> stringFutureTask = new FutureTask<String>(demo3);

        new Thread(stringFutureTask).start();

        /**
         * 时间片轮转调度：又称RP调度，每个进程被分配一个时间段，称作它的时间片，即该进程允许运动的时间。
         *
         * 1、进程是程序运行资源分配的最小单位，
         *
         * 同一进程中的多条线程共享该进程中的全部系统资源，而进程和进程之间是相互独立的
         *
         * 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动
         *
         * 进程是系统进行资源分配和调度的一个独立单位
         *
         * 进程是程序在计算机上的一次执行活动
         *
         * 2、线程是cpu调度的最小单位，必须依赖于进程而存在
         *
         * 线程是进程的一个实体，是cpu调度和分派的基本单位
         *
         * ## 线程简单实现的三种方法
         *
         * extends Thread 覆盖run方法， new一个线程对象， start 启动该线程
         *
         * 实现Runable接口，实现run方法
         *
         * implement Callable 实现call方法可以得到线程的执行结果
         *
         * @create 2019-05-16 liu
         **/


        System.out.println();
        Thread d2 = new Thread(new Demo22(), "线程属性");


        System.out.println("线程中断");
        /**
         * stop 已经过时
         *  interrupt 线程自己处理中断
         * @create 2019-05-16 liu
         **/
        d2.interrupt();
        boolean interrupted = d2.isInterrupted();

        for (int i = 0; i < 100; i++) {
            Thread t1 = new Thread(new Demo22(), "线程属性" + i);
            t1.start();

            System.out.println(t1.isInterrupted() + "   =   isInterrupted");
            // java.lang.InterruptedException: sleep interrupt
            // sleep 的线程无法中断
            // t1.interrupt();
        }


        /**
         * 线程的五种状态
         * 新建、就绪、运行、堵塞、死亡
         * sleep：释放cpu的执行权，不释放锁
         * wait：释放cpu的执行权，释放锁，
         * notify 唤醒锁，必须拥有相同对象锁
         * yied 对当前进程进行临时暂停，让出cpu的使用权
         * @create 2019-05-16 liu
         **/

        /**
         * 守护线程
         * 也就是后台线程，进程结束，守护进程就结束，
         * setDaemon  在进程启动前  设置为守护进程了
         *
         * jre判断程序是否执行结束的标准是所有的前台执行完毕，不管后台线程的状态
         *
         * 线程副本  threadLocal
         * 为每个使用改变了的线程提供独立的变量副本，每个线程都可以独立的改变自己的副本，不回影响其他线程所对应的副本
         * 线程结束后，对应该线程的局部变量将自动被垃圾回收
         * @create 2019-05-16 liu
         **/

        ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>() {
            @Override
            protected Integer initialValue() {
                return 0;
            }
        };


        Thread thread = new Thread(() -> {
            //使用线程变量
            // System.out.println(threadLocal.get());
            // threadLocal.remove();  // 移除
        });

        /**
         * 使用了一个和当前线程相关的 ThreadLocalMap 然后将变量的值设置到这个map中
         * ThreadLocalMap 是ThreadLocal类中的一个静态内部类
         * 每个线程有有一个
         * 使用当前的线程作为key
         * @create 2019-05-16 liu
         **/


        /**
         * 所有的异常必须在run 方法内进行处理
         * 线程是独立执行的代码片段
         * 线程的问题由线程自己解决
         * @create 2019-05-16 liu
         **/

    }

    static class Demo22 implements Runnable {
        @Override
        public void run() {
            System.out.println("Demo22  running");
            try {
                Thread.sleep(2222);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Thread thread = Thread.currentThread();
            System.out.println("线程名：" + thread.getName());
            System.out.println("优先级：" + thread.getPriority());
            System.out.println("状态：" + thread.getState());
            System.out.println("存活：" + thread.isAlive());
            System.out.println("守护：" + thread.isDaemon());
            System.out.println("id：" + thread.getId());
        }
    }


    static class Demo3 implements Callable<String> {

        @Override
        public String call() throws Exception {
            System.out.println("demo 3  running ");
            return null;
        }
    }

    static class Demo2 implements Runnable {
        @Override
        public void run() {
            System.out.println("Demo2  running");

        }
    }

    static class DemoA extends Thread {

        @Override
        public void run() {
            super.run();

            System.out.println("DemoA  线程启动呢");
        }
    }
}

public class MyThreadLocal {
	static class ThreadMain{
		
		
		private static ThreadLocal<Integer> seqNum = new ThreadLocal<Integer>(){
			@Override
			protected Integer initialValue() {
				return 0 ;
			}
			
		};
		
		
		/*
		 * ThreadLocal为每个使用该变量的线程提供独立的变量副本
		 * 每个线程都可以独立的改变自己的副本，不影响其他线程所对应的副本
		 * 目标变量就像是本地变量
		 * 
		 * set 设置当前线程的线程局部变量的值
		 * get返回当前线程所对应的线程局部变量
		 * remove 将当前线程局部变量的值删除，线程结束后，该变量会自动被回收，使用该方法可以加快内存回收速度
		 * initialValue  返回该线程局部变量的初始值，
		 * 这个方法是一个延迟调用方法，在第一次get/set时才执行，只执行一次，缺省返回一个null
		 * 
		 */
		
		/*
		 * ThreadLocal 实现了线程的变量拷贝
		 * 
		 * 线程隔离的实现就是ThreadLocalMap这个类
		 * 是ThreadLocal类的一个静态内部类
		 * 实现了键值对的设置和取值
		 * 每个线程中都有一个独立的ThreadLocalMap副本
		 * 存储的值只能被当前线程读取和修改
		 * 每个线程只能操作自己的线程副本从而实现了线程隔离
		 */
		
		/*
		 * 在处理线程的局部变量的时候比synchronized同步机制解决线程安全问题更简单
		 * 结果程序拥有更高的并发性
		 * 一般都是声明在静态变量中的threadlocal
		 * 不断创建没有调用remove，将会导致内存泄漏
		 */
		public ThreadLocal<Integer> getThreadLocal() {
			return seqNum;
			
		}
		
		public int getNextNum() {
			seqNum.set(seqNum.get() +1);
			return seqNum.get();
			
		}
		
	}
	
	  static class TestClient extends Thread {
		
		private ThreadMain sn ;
		public TestClient(ThreadMain sn) {
			this.sn = sn;
			
		}
		@Override
		public void run() {
			for (int i = 0 ; i < 5 ;i++){
				System.out.println(Thread.currentThread().getName() 
						+ ",sn = " + sn.getNextNum()
				        + " ,id = " + Thread.currentThread().getId());
				System.err.println();
				sn.getThreadLocal().remove();
			}
		}
		
	}

	public static void main(String[] args) {
		ThreadMain sn = new ThreadMain();
		TestClient testClient = new TestClient(sn);
		TestClient testClient2 = new TestClient(sn);
		testClient.start();
		testClient2.start();
	}
}