java多线程

一、创建线程

1.继承Thread类

public class ThreadTest extends Thread{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " is running");
    }

    public static void main(String[] args) {
        new ThreadTest().start();
        new ThreadTest().start();
    }
}

2.实现Runnable接口

public class RunnableTest implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " is running");
    }
    
    public static void main(String[] args) {

        RunnableTest runnableTest = new RunnableTest();
        
        new Thread(runnableTest,"线程1").start();
        new Thread(runnableTest,"线程2").start();
    }
}

3.Callable和Future

public class CallableTest implements Callable<String> {

    @Override
    public String call(){
        System.out.println(Thread.currentThread().getName()+" is running");
        return "ok";
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        Callable<String> callable  =new CallableTest();
        Thread thread1=new Thread(new FutureTask<>(callable));
        Thread thread2=new Thread(new FutureTask<>(callable));
//		thread1.setName("线程一");
        thread1.start();
        thread2.start();
        //System.out.println(futureTask.get());
    }
}

4.线程池

newCachedThreadPool()
缓存型池子，先查看池中有没有以前建立的线程，如果有，如果没有，就建一个新的线程加入池中
newFixedThreadPool(int)
最多只能有固定数目的活动线程存在，此时如果有新的线程要建立，只能放在另外的队列中等待
newScheduledThreadPool(int)
调度型线程池，这个池子里的线程可以按schedule依次delay执行，或周期执行 SingleThreadExecutor()
单例线程，任意时间池中只能有一个线程

public class test {
    public static void main(String args[]){
        new threadPool().run();
    }
}

class threadPool{
    public void run() {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i =0;i<10;i++) {
            executorService.execute(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + ":doSomething start");
                    Thread.sleep(2000);
                    System.out.println(Thread.currentThread().getName() + ":doSomething end");
                } catch (Exception e) {

                }
            });
        }
        executorService.shutdown();
    }
}

二.锁

1.synchronized

Java语言内置关键字，JVM会让线程自动释放锁。

2.ReentrantLock

是一个类，通过这个类可以实现同步访问，必须要用户去手动释放锁。独占锁

3.Semaphore

信号量，类似PV原语，acquire()减少信号量，release()增多信号量。共享锁

4.CountDownLatch

与join()功能类似，当前执行线程等待join线程执行结束。是主等客的关系。

5.CyclicBarrier

类似软件测试里讲的集合点的概念（性能测试）。这个类也可以实现一组线程在到达某个条件之前进行等待，是客与客之间的关系。比如，王者荣耀等10个人都100%才开始游戏。它们内部都有一个计数器，当计数器的值不断的减为0的时候所有阻塞的线程将会被唤醒。

6.AbstractQueuedSynchronizer（AQS）

上面的类都依赖与AQS所提供的队列式同步器。每个线程封装在Node。源码分析交给大佬，我就到此为止。