Java三大线程同步机制代码实战指南

1.创建一个Thread类的子类 class MyThread extends Thread
2.在Thread类的子类中重写Thread类中的run()方法
3.创建Thread类的子类对象 MyThread t1 = new MyThread();
4.调用Thread类中的方法start()方法,开启新的线程,执行run方法 t1.start()

class MyThread extends Thread {
    @Override
    public void run() {
    }
}
public class demo21Thread01 {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start();
    }
}

class myThread02 implements Runnable {
    public void run() {
    }
}
public class demo21Thread01 {
    public static void main(String args[]) throws InterruptedException {
        myThread02 mythread = new myThread02();
        Thread t = new Thread(mythread);
        t.start();
    }
}

class MyTask implements Callable<String> {
    @Override
    public String call() throws Exception {
        try {
            // 模拟业务处理
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "success";
    }
}
public class demo21Thread01 {
    public static void main(String[] args) throws Exception {
        // 1、callable怎么用，引入FutureTask初始化
        FutureTask<String> futureTask = new FutureTask<>(new MyTask());
        new Thread(futureTask).start();
        // 2、FutureTask线程启动，与main线程互不干扰
        while (!futureTask.isDone()) {
        }
        // 3、获得返回值：get方法尽量放在后面，一旦调用，线程等待等到执行完毕，会导致堵塞
        String value = futureTask.get();
        System.out.println("MyData的返回值:" + value);
    }
}

ExecutorService es= Executors.newCachedThreadPool();		//缓存型线程池
ExecutorService es= Executors.newFixedThreadPool(2);		//固定型线程池
ExecutorService es=Executors.newSingleThreadExecutor();  	//单线程型线程池
以上三种通过es.submit(new MyRunable03(i));提交任务
ScheduledExecutorService es = Executors.newScheduledThreadPool(3);//延迟执行或重复执行型线程池
通过es.schedule(new myRunnable(i), 2, TimeUnit.SECONDS);提交任务

new Thread(() -> {
    System.out.println("程序已启动");
}).start();

package thread;
/*
 * 两个线依次次输出1 2 3 4
 */
public class ThreadSyncTest2 {
    // 使用专用锁对象（不可变）
    private static Object LOCK = new Object();
    private static int num = 1;
    public static void main(String[] args) {
        new Thread(() -> {
            while (num <= 10) {
                try {
                    synchronized (LOCK) {
                        if (num % 2 == 0) {
                            System.out.println("偶数线程A: " + num++);
                            LOCK.notify();
                        } else {
                            LOCK.wait();
                        }
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }, "偶数线程A").start();
        new Thread(() -> {
            while (num <= 10) {
                try {
                    synchronized (LOCK) {
                        if (num % 2 == 1) {
                            System.out.println("基数线程B: " + num++);
                            LOCK.notify();
                        } else {
                            LOCK.wait();
                        }
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }, "基数线程B").start();
    }
}

package thread;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
/*
 * 两个线程一次输出1 2 3 4
 */
public class ThreadSyncTest3 {
    private static int num = 1;
    // 锁与条件变量
    private static final ReentrantLock LOCK = new ReentrantLock();
    private static final Condition ODD_COND = LOCK.newCondition();    // 奇数条件队列
    private static final Condition EVEN_COND = LOCK.newCondition();    // 偶数条件队列
    public static void main(String[] args) {
        new Thread(() -> {
            while (num <= 10) {
                LOCK.lock();
                try {
                    if (num % 2 == 0) {
                        System.out.println("偶数线程A: " + num++);
                        ODD_COND.signal();
                    } else {
                        EVEN_COND.await();
                    }
                } catch (InterruptedException e) {
                    break;
                } finally {
                    LOCK.unlock();
                }
            }
            EVEN_COND.signal();
        }, "偶数线程A").start();
        new Thread(() -> {
            while (num <= 10) {
                LOCK.lock();
                try {
                    if (num % 2 == 1) {
                        System.out.println("基数线程B: " + num++);
                        EVEN_COND.signal();
                    } else {
                        ODD_COND.await();
                    }
                } catch (InterruptedException e) {
                    break;
                } finally {
                    LOCK.unlock();
                }
            }
            EVEN_COND.signal();
        }, "基数线程B").start();
    }
}