java上下文传输 什么是java上下文

目录

1.上下文切换

2.实现多线程方式

3.Thread类的几个常用方法

4.Thread 和 Runnable 比较

5.Callable、Future、FutureTask

5.1 Callable

5.2 FutureTask

6.Java线程间的通信

6.1 锁与同步

6.2 等待/通知机制

 6.3 信号量 volatile

6.4 管道

6.5 其它通信相关

6.5.1 join 方法

6.5.2 sleep 方法

6.5.3 ThreadLocal 类

---

1.上下文切换

上下文切换指 cpu 从一个进程（或线程）切换到另一个进程（或线程）。上下文指某一时间点cpu 寄存器和程序计数器的内容。

上下文切换通常是计算密集型的，意味着此操作会消耗大量 cpu 时间，所以线程不是越多越好。

2.实现多线程方式

继承 Thread 类

public class Demo {
    public static class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("MyThread");
        }
    }

    public static void main(String[] args) {
        Thread myThread = new MyThread();
        myThread.start();
    }
}

实现 Runnable 接口

public class Demo {
    public static class MyThread implements Runnable {
        @Override
        public void run() {
            System.out.println("MyThread");
        }
    }

    public static void main(String[] args) {

        new Thread(new MyThread()).start();

        // Java 8 函数式编程，可以省略MyThread类
        new Thread(() -> {
            System.out.println("Java 8 匿名内部类");
        }).start();
    }
}

3.Thread类的几个常用方法

concurrentThread：返回当前正在执行的线程对象

start：开始执行线程，java虚拟机会调用 线程的 run 方法

yield：当前线程让出处理器的占用

sleep：当前线程睡眠一段时间

join：当前线程等待另一个线程执行完毕再继续执行。内部调用object 的 wait 方法实现的

4.Thread 和 Runnable 比较

单继承，多实现

Threa实现了 Runnable 接口

5.Callable、Future、FutureTask

5.1 Callable

与Runnable 接口类似，但是Callable接口是有返回值的，而且支持泛型。

Callable 接口一般配合线程池工具类 ExecutorService 来使用的：

// 自定义Callable
class Task implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        // 模拟计算需要一秒
        Thread.sleep(1000);
        return 2;
    }
    public static void main(String args[]) throws Exception {
        // 使用
        ExecutorService executor = Executors.newCachedThreadPool();
        Task task = new Task();
        Future<Integer> result = executor.submit(task);
        // 注意调用get方法会阻塞当前线程，直到得到结果。
        // 所以实际编码中建议使用可以设置超时时间的重载get方法。
        System.out.println(result.get()); 
    }
}

5.2 FutureTask

FutureTask类有什么用？为什么要有这一个类？

Future只是一个接口，而它里面的 cancel，get，isDone等方法要自己实现起来都是非常复杂的。所以JDK提供了一个 FutureTask 类来供我们使用。

// 自定义Callable，与上面一样
class Task implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        // 模拟计算需要一秒
        Thread.sleep(1000);
        return 2;
    }
    public static void main(String args[]) throws Exception {
        // 使用
        ExecutorService executor = Executors.newCachedThreadPool();
        FutureTask<Integer> futureTask = new FutureTask<>(new Task());
        executor.submit(futureTask);
        System.out.println(futureTask.get());
    }
}

6.Java线程间的通信

6.1 锁与同步

Java中的锁是基于对象的，一般叫对象锁。线程同步可以解释为线程按照一定顺序执行。

public class ObjectLock {
    private static Object lock = new Object();

    static class ThreadA implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                for (int i = 0; i < 100; i++) {
                    System.out.println("Thread A " + i);
                }
            }
        }
    }

    static class ThreadB implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                for (int i = 0; i < 100; i++) {
                    System.out.println("Thread B " + i);
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new Thread(new ThreadA()).start();
        Thread.sleep(10);
        new Thread(new ThreadB()).start();
    }
}

这里申明了一个 lock 的对象锁，在两个线程中使用 synchronized 关键字加上了同一个对象锁。

6.2 等待/通知机制

基于 Object 类的 wait 方法和 notify 方法和 notifyAll 方法实现的。

notify 是随机唤醒一个线程，notifyAll 唤醒所有线程

 加入线程A获得了对象 obj 锁，执行同步代码块。在同步代码中调用 obj.wait 方法进入等待状态，这个时候锁被释放。

这个时候线程B获得对象 obj 锁，执行代码块，某一时刻调用 obj.notifyAll 唤醒其它线程，然后调用 wait 释放锁或者等线程执行完成再释放锁。

public class WaitAndNotify {
    private static Object lock = new Object();

    static class ThreadA implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                for (int i = 0; i < 5; i++) {
                    try {
                        System.out.println("ThreadA: " + i);
                        lock.notify();
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                lock.notify();
            }
        }
    }

    static class ThreadB implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                for (int i = 0; i < 5; i++) {
                    try {
                        System.out.println("ThreadB: " + i);
                        lock.notify();
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                lock.notify();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new Thread(new ThreadA()).start();
        Thread.sleep(1000);
        new Thread(new ThreadB()).start();
    }
}

需要注意的是等待/通知机制使用的是同一个对象锁，不同的对象锁不能用等待/通知机制。

 6.3 信号量 volatile

这里意思是使用 volatile 关键字修饰线程共享变量，让变量在线程间可见。

例：让两个线程交替执行

public class Signal {
    private static volatile int signal = 0;

    static class ThreadA implements Runnable {
        @Override
        public void run() {
            while (signal < 5) {
                if (signal % 2 == 0) {
                    System.out.println("threadA: " + signal);
                    signal++;
                }
            }
        }
    }

    static class ThreadB implements Runnable {
        @Override
        public void run() {
            while (signal < 5) {
                if (signal % 2 == 1) {
                    System.out.println("threadB: " + signal);
                    signal = signal + 1;
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new Thread(new ThreadA()).start();
        Thread.sleep(1000);
        new Thread(new ThreadB()).start();
    }
}

volatile 变量需要进行原子操作，这里的 signal ++ 操作不是原子操作。根据需要使用 synchronized 给它上锁，或者使用 AutomaticInteger 等原子类。这一段代码不是线程安全的，进入while 循环语句后，当前线程可能CPU时间片使用玩进入等待时间，等重新获得 CPU时 signal 已经大于当前值了

6.4 管道

基于“管道流”的通信方式。JDK提供了 PipedWriter、PipedReader、PipedOutStream、PipedInputStream。前面两个基于字符流，后面两个基于字节流

public class Pipe {
    static class ReaderThread implements Runnable {
        private PipedReader reader;

        public ReaderThread(PipedReader reader) {
            this.reader = reader;
        }

        @Override
        public void run() {
            System.out.println("this is reader");
            int receive = 0;
            try {
                while ((receive = reader.read()) != -1) {
                    System.out.print((char)receive);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    static class WriterThread implements Runnable {

        private PipedWriter writer;

        public WriterThread(PipedWriter writer) {
            this.writer = writer;
        }

        @Override
        public void run() {
            System.out.println("this is writer");
            int receive = 0;
            try {
                writer.write("test");
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) throws IOException, InterruptedException {
        PipedWriter writer = new PipedWriter();
        PipedReader reader = new PipedReader();
        writer.connect(reader); // 这里注意一定要连接，才能通信

        new Thread(new ReaderThread(reader)).start();
        Thread.sleep(1000);
        new Thread(new WriterThread(writer)).start();
    }
}

6.5 其它通信相关

6.5.1 join 方法

join 方法是 Thread 的实例方法。让当前线程进入“等待”状态，等调用 join 方法的线程执行结束后，再执行当前线程。

public class Join {
    static class ThreadA implements Runnable {

        @Override
        public void run() {
            try {
                System.out.println("我是子线程，我先睡一秒");
                Thread.sleep(1000);
                System.out.println("我是子线程，我睡完了一秒");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new ThreadA());
        thread.start();
        thread.join();
        System.out.println("如果不加join方法，我会先被打出来，加了就不一样了");
    }
}

join 方法有两个重载方法，join（long ）、join（long，int）。底层都是调用 wait（long）方法。 

6.5.2 sleep 方法

sleep 方法是 Thread 类的一个静态方法。让当前线程随眠一段时间。

sleep 方法不会释放当前锁，wait 方法回释放锁

【wait】、【sleep】区别：

sleep 必须指定时间。

wait 释放CPU同时释放锁；sleep释放CPU但不释放锁，容易死锁。

wait 必须放在同步代码块中

6.5.3 ThreadLocal 类

ThreadLocal是一个本地线程副本变量工具类。内部是一个弱引用的Map来维护。

ThreadLocal类最常用的就是set方法和get方法。示例代码：

public class ThreadLocalDemo {
    static class ThreadA implements Runnable {
        private ThreadLocal<String> threadLocal;

        public ThreadA(ThreadLocal<String> threadLocal) {
            this.threadLocal = threadLocal;
        }

        @Override
        public void run() {
            threadLocal.set("A");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("ThreadA输出：" + threadLocal.get());
        }

        static class ThreadB implements Runnable {
            private ThreadLocal<String> threadLocal;

            public ThreadB(ThreadLocal<String> threadLocal) {
                this.threadLocal = threadLocal;
            }

            @Override
            public void run() {
                threadLocal.set("B");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("ThreadB输出：" + threadLocal.get());
            }
        }

        public static void main(String[] args) {
            ThreadLocal<String> threadLocal = new ThreadLocal<>();
            new Thread(new ThreadA(threadLocal)).start();
            new Thread(new ThreadB(threadLocal)).start();
        }
    }
}

如果只是单纯的想要线程隔离，在每个线程中声明一个私有变量就好了呀，为什么要使用ThreadLocal？

如果开发者希望将类的某个静态变量（user ID或者transaction ID）与线程状态关联，则可以考虑使用ThreadLocal。

最常见的ThreadLocal使用场景为用来解决数据库连接、Session管理等。数据库连接和Session管理涉及多个复杂对象的初始化和关闭。如果在每个线程中声明一些私有变量来进行操作，那这个线程就变得不那么“轻量”了，需要频繁的创建和关闭连接。