JAVA并发编程学习笔记一 ------多线程的建立方式

1.extend Thread 类

public class extendThreadClass  extends Thread {

    public extendThreadClass(String name){
        /*
        调用父类的构造器，赋值name
         */
        super(name);
    }

    @Override
    public void run() {
        while(!interrupted()){
            System.out.println(getName()+"线程执行了。。。");

            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

    }

    public static void main(String[] args) {
        extendThreadClass demo1 = new extendThreadClass("Thread 1");
        extendThreadClass demo2 = new extendThreadClass("Thread 2");
        demo1.start();
        demo2.start();
        //stop方法只是让线程无限期等待，并无释放资源和锁之类的 interrupt推荐使用  可是使用该方法时，
            须要判断线程是否处于中断状态
        demo1.interrupt();
//        //守护线程，程序执行完，跟着推出，跟随主线程完毕而完毕
//        demo1.setDaemon(true);



    }
}

须要注意的是复写父类的run方法，  父类的构造器有多种，原理是多态实现不一样参数下的构造，
主要参数分为线程组，线程名称，runable接口 还有stackSize栈的大小

其次就是setDeamon这个方法，这是个接收boolean值的方法，设置为true的状况下，代表为守护线程，意义在于，主线程执行完成时，不管该线程是否执行完成，也跟着主线程退出而退出，该种方式建立线程无返回值

2.implenment Runable

public class implementRunable implements Runnable {
/*
实现runable接口的本质，并非建立一个线程，而是建立一个线程任务，通俗意思就是，我知道我能作什么，可是我没有动力本身去作
面向接口
没有返回值，也不能抛出异常
 */
    @Override
    public void run() {
        while(true){
            System.out.println("thread is run...");
        }
    }

    public static void main(String[] args) {
        //使用Tread类的构造有参构造方法
        Thread thread1 = new Thread(new implementRunable(),"thread1");
        thread1.start();

    }
}

3.使用匿名内部类建立线程

/**
 * Created by 14029 on 2018/1/18.
 * 使用匿名内部类建立线程
 * 适用于只使用一次的线程
 * 匿名内部类必须实现一个接口
 * 方法体中本质是实现接口的方法
 *
 * 若是同时实现runable  和复写run方法  被执行的是被重写的run方法  ，，，由于不会去调父类的RUN方法 动态分派调用 多态实现
 * 没有返回值，也不能抛出异常
 */
public class useInnerClasswithoutname {
    public static void main(String[] args) {
//        new Thread(){
//            public void run(){
//                System.out.println("thread is run .....");
//            };
//        }.start();
//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println("runable is start");
//            }
//        }).start();


        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("runable is start");
            }
        }){
            public void run(){
                System.out.println("Thread is start");
            }
        }.start();
    }
}

4 . implements Callable<V>

/**
 * Created by 14029 on 2018/1/18.
 * 泛型指定返回值类型
 */
public class implementsCallable implements Callable <Integer>{
    @Override
    /*
    相似RUN方法
     */
    public Integer call() throws Exception {
        System.out.println("is runing ");
        Thread.sleep(3000);
        return  1;

    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        implementsCallable demo = new implementsCallable();
        //FutureTask提早任务，本质是对runable接口的封装 实现线程任务
        //提早任务，出现先执行了do other2 --》is runinng  --》do other1 -->result 主线程继续执行
        FutureTask<Integer> task1 = new FutureTask<Integer>(demo);
        Thread thread = new Thread(task1);
        thread.start();
        System.out.println("i do other2");
        int result = task1.get();
        System.out.println("i do other1");
        System.out.println("Thread result is ..."+result);

    }
}

本质是对runable的继承和封装，而后建立task，建立线程，执行task

5.使用线程池建立线程

/**
 * Created by 14029 on 2018/1/18.
 * 方便演示用的Executor
 * 同时说明如今的状况最好不用该种方式
 */
public class usethreadpool {
    public static void main(String[] args) {
        //建立固定大小线程池
        /*
        线程池不容许使用Executors去建立，而是经过ThreadPoolExecutor的方式，这样的处理方式让写的同窗更加明确线程池的运行规则，规避资源耗尽的风险。 说明：Executors各个方法的弊端：
1）newFixedThreadPool和newSingleThreadExecutor:
  主要问题是堆积的请求处理队列可能会耗费很是大的内存，甚至OOM。
2）newCachedThreadPool和newScheduledThreadPool:
  主要问题是线程数最大数是Integer.MAX_VALUE，可能会建立数量很是多的线程，甚至OOM。
         */
//改方法建立固定大小的线程池
        Executor ThreadPool = Executors.newFixedThreadPool(10);
//该方法随着线程任务的执行，动态分配线程池的大小
        Executor ThreadPool1 = Executors.newCachedThreadPool();

        ThreadPool.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("is running ");
            }
        });

    }

}

6.Use Timer

/**
 * Created by 14029 on 2018/1/18.
 *
 * 多用于定时任务，著名框架（quartz）
 * 使用定时器实现多线程
 * 多线程并行处理定时任务时，Timer运行多个TimeTask时，只要其中之一没有捕获抛出的异常，
其它任务便会自动终止运行，使用ScheduledExecutorService则没有这个问题。
 * 有返回值
 * 不可控
 */
public class useTimer {
    /*
    定时任务 0延迟 1000毫秒一次
该方法是链式调用，只要其中之一没有捕获抛出的异常，
其它任务便会自动终止运行

     */
    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                //实现定时任务
                System.out.println("task is run....");
            }
        },0,1000);
    }




}

7使用Spring 实现多线程

public class useSpring {
    /**使用spring 实现多线程，使用maven 导入Spring依赖
     * 配置注解  @Configuration
     * 第一步配置扫描包 注解：  @ComponentScan("包名")
     * 第二部打开异步   注解： @EnableAsync
     *第三步 建立 异步处理逻辑类   使用@service 将类交给Spring 管理 见 useSpringdomain
     * 第四部 domain
     */
}


/*
config类
Config.java
@Configuration
@ComponentScan("包名")
@EnableAsync
public class config{}
 */

/*
useSpringdomain.java
@Service
public class useSpringdomain{
@Async  异步
public void a(){
while(true){
//todo
}
@Async  异步
public void b(){
while(true){
//todo
}
}
}
 */

/*
domain.java
核心：
AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(config.class)
useSpringdomain demo1 =ac.getBean(useSpringdomain.class)
demo1.a();


 */

8 使用Lambda实现多线程

parallelStream 经过并发流的方式实现多线程。。。没有具体研究