java线程

1.创建线程

public class TestThread {
    public static void main(String[] args) {
        Thread1 thread1 = new Thread1();
        thread1.start();

        Thread thread2 = new Thread(new Thread2());
        thread2.start();
    }
}
class Thread1 extends Thread {
    @Override
    public void run() {
        System.out.println("方式1：继承Thread类");
    }
}
class Thread2 implements Runnable {
    @Override
    public void run() {
        System.out.println("方式2：实现Runnable接口");
    }
}
public class Callable01 implements Callable<String> {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask task = new FutureTask(new Callable01());
        new Thread(task).start();
        System.out.println(task.get());//内部自旋阻塞
    }

    @Override
    public String call() throws Exception {
        return "方式3：实现Callable泛型接口";
    }
}

2.线程状态

new 初始状态
runnable 运行状态，就绪和运行中
blocked 阻塞状态 synchronized
waiting 等待，需要其他线程做出一些特定动作 wait/notify、join
time_waiting 超时等待，可以在指定的时间自行返回,sleep、join
terminated 终止状态

public class ThreadState {
    public static void main(String[] args) {
        new Thread(new TimeWaiting(), "TimeWaitingThread").start();
        new Thread(new Waiting(), "WaitingThread").start();
        new Thread(new Blocked(), "BlockedThread-1").start();
        new Thread(new Blocked(), "BlockedThread-2").start();
    }

    static class TimeWaiting implements Runnable {
        @Override
        public void run() {
            while (true) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    static class Waiting implements Runnable {
        @Override
        public void run() {
            while (true) {
                synchronized (Waiting.class) {
                    try {
                        Waiting.class.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    static class Blocked implements Runnable {
        @Override
        public void run() {
            synchronized (Blocked.class) {
                while (true) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

3.线程执行顺序（join）

public class ThreadSort {
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("thread1");
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("thread2");
            }
        });
        Thread thread3 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("thread3");
            }
        });

        thread1.start();
        thread1.join();
        thread2.start();
        thread2.join();
        thread3.start();
        thread3.join();
    }
}

4.线程池

线程和线程池比较，这里线程池比线程性能高了10倍左右

public class TestThreadPool {
    public static void main(String[] args) throws InterruptedException {
        Long start = System.currentTimeMillis();
        final List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            final int j = i;
            Thread thread = new Thread() {
                @Override
                public void run() {
                    list.add(j);
                }
            };
            thread.start();
            thread.join();//主线程等待子线程结束
        }
        System.out.println(System.currentTimeMillis() - start);
        System.out.println(list.size());//1800
    }

    public static void main2(String[] args) throws InterruptedException {
        Long start = System.currentTimeMillis();
        final List<Integer> list = new ArrayList<>();
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10000; i++) {
            final int j = i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    list.add(j);
                }
            });
        }
        executorService.shutdown();
        executorService.awaitTermination(1, TimeUnit.DAYS);//主线程等待子线程1天
        System.out.println(System.currentTimeMillis() - start);
        System.out.println(list.size());//20
    }
}

5.线程池种类

• 普通线程池
• 定时线程池
  

6.volatile

线程间变量可见性

public class App {
    public static void main(String[] args) throws InterruptedException {
        Test test = new Test();
        new Thread(() -> {
            test.doWork();
        }).start();
        Thread.sleep(1000);
        new Thread(() -> {
            test.shutDown();
        }).start();
    }
}

class Test {
    volatile boolean _shutDown = false;

    public void doWork() {
        while (!_shutDown) {
            //中间没有时间间隔的情况下，无法获取_shutDown变更后的值
            /*try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }*/
            //System.out.println("执行中。。。");
        }
        System.out.println("系统被关闭了");
    }

    public void shutDown() {
        _shutDown = true;
    }
}

7.ReentrantLock（手动锁）

常用方法：

• lock 获得锁
• unlock 释放锁
• tryLock(long timeout, TimeUnit unit) 等待获得锁
• lockInterruptibly() 中断锁

public class TestLock {
    public static void main(String[] args) {
        Test1 test1 = new Test1();
        new Thread(() -> {
            test1.test();
        }, "thread-1").start();
        new Thread(() -> {
            test1.test();
        }, "thread-2").start();
    }
}

class Test1 {
    ReentrantLock lock = new ReentrantLock();

    public void test() {
        try {
            if (lock.tryLock(5, TimeUnit.SECONDS)) {
                System.out.println(Thread.currentThread().getName() + "获得锁");
                try {
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } finally {
                    lock.unlock();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}