线程基础

//第一种方法 继承Thread类
public class MyThread extends Thread{
    public void run(){
        for(int i=1;i<=5;i++){
            System.out.println(Thread.currentThread().getName()+"===========>"+i);
        }
    }
}

下图为测试类.

public class Demo01 {
    public static void main(String[] args) {
            Thread t1=new MyThread();
            t1.setName("线程1");
            t1.start();
            Thread t2=new MyThread();
            t2.setName("线程2");
            t2.start();


    }
}

（二）、实现Runnable接口

//方式2：实现Runnable接口
public class MyThread1 implements Runnable {
    @Override
    public void run() {
        for(int i=1;i<=5;i++){
            System.out.println(Thread.currentThread().getName()+"=======>"+i);
        }
    }
}

测试类：

public class Demo02 {
    public static void main(String[] args) {
        MyThread1 t=new MyThread1();
        Thread t1=new Thread(t,"线程1");
        t1.start();
        Thread t2=new Thread(t,"线程2");
        t2.start();
    }
}

（三）实现Callable接口

import java.util.concurrent.Callable;

//方法3：实现Callable接口
public class MyThread3 implements Callable {
    int sum=0;
    @Override
    public Object call() throws Exception {
        for(int i=1;i<=5;i++){
            sum=sum+i;
        }

        return sum;
    }
}

测试类：



import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

//实现Callable接口
public class Demo03 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //=======拿到线程的返回  实现CallAble接口========
        MyThread3 m=new MyThread3();
        FutureTask<Integer> ft=new FutureTask<Integer>(m);
        Thread t=new Thread(ft);
        t.start();
        Integer sum=ft.get();
        System.out.println(sum);
    }
}

※（四）线程池创建

1、线程池概念

• 现有问题：

• 线程是宝贵的内存资源、单个线程约占1MB空间，过多分配易造成内存溢出。

• 频繁的创建及销毁线程会增加虚拟机回收频率、资源开销，造成程序性能下降。

• 线程池：

• 线程容器，可设定线程分配的数量上限。

• 将预先创建的线程对象存入池中，并重用线程池中的线程对象。

• 避免频繁的创建和销毁。

2、线程池原理

其实线程池顾名思义就是事先创建若干个可执行的线程放入一个池（容器）中，需要的时候从池中获取线程不用自行创建，使用完毕不需要销毁线程而是放回池中，从而减少创建和销毁线程对象的开销。
（1）降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
（2）提高响应速度。当任务到达时，任务可以不需要等到线程创建就能执行。
（3）提高线程的可管理性，线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。

3、创建线程池

import java.util.concurrent.Callable;

public class MyThread3 implements Callable {
    int sum=0;
    @Override
    public Object call() throws Exception {
        for(int i=0;i<=100;i++){
            sum=sum+i;
        }

        return sum;
    }
}


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


public class Demo04 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService pool= Executors.newFixedThreadPool(5);
        MyThread3 m=new MyThread3();
                FutureTask<Integer> ft = new FutureTask<Integer>(m);
        pool.submit(ft);//Thread t1 = new Thread(ft);
        Integer res = ft.get();
        System.out.println(res);
        pool.submit(m);
    }
}

运行结果（这四种方法的运行结果是一样的、所以我在这只放一个运行结果的截图）