Java多线程详细知识总结 用实例代码展示具体的使用

* 多线程的创建，方式一：继承于Thread类
 * 1. 创建一个继承于Thread类的子类
 * 2. 重写Thread类的run() --> 将此线程执行的操作声明在run()中
 * 3. 创建Thread类的子类的对象
 * 4. 通过此对象调用start()
 * 例子：遍历100以内的所有的偶数

//1、创建一个继承于Thread类的子类
class Thread01 extends Thread {
    //2、重写Thread类的run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        //3、创建Thread类的子类的对象
        Thread01 thread01 = new Thread01();
        //4.通过此对象调用start()
        thread01.start();

        //创建第二个线程
        Thread01 thread02 = new Thread01();

        //注意：这里我们不能直接手动调用 run()方法
        //thread01.run();

        //注意：当我们再次调用start()时会直接报错：IllegalThreadStateException,所以一个线程只能用一次
        //thread01.start();

        thread02.start();


        //当前操作仍然是在main线程中执行
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i + "主线程被执行了");
            }

        }
    }
}

public class ThreadTest01 {
    public static void main(String[] args) {

        //线程一：偶数
        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    if (i % 2 == 0) {
                        System.out.println(Thread.currentThread().getName() + "线程一偶数的执行数：" + i);
                    }
                }
            }
        }.start();


        //线程二：奇数
        new Thread() {
            @Override
            public void run() {

                for (int i = 0; i < 100; i++) {
                    if (i % 2 != 0) {
                        System.out.println(Thread.currentThread().getName() + "线程二奇数的执行数：" + i);
                    }
                }
            }
        }.start();
    }
}

* @description: 多线程具体方法的使用
 * @date 2021/4/16 18:32
 */


class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority() + ":" + i);

                //设置线程睡眠时间
               /* try {
                    sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }*/
            }
            //当满足当前条件时，终止线程
            /*if (i % 20 == 0) {
                yield();
            }*/


        }

    }
}

public class ThreadMethodTest {
    public static void main(String[] args) {
        MyThread thread = new MyThread();

        thread.start();
        //给主线程命名
        thread.setName("我是线程一号");
        //将分线程优先级设置成最大
        thread.setPriority(Thread.MAX_PRIORITY);

        Thread.currentThread().setName("我是主线程");
        //将主线程的优先级设置成最小
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);

        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority() + ":" + i);
            }
            //join()表示：线程A中调用线程B的join()方法,那么此时线程A进入阻塞状态，直到线程B完全执行完以后，线程A才
            //结束阻塞状态。
            /*if (i == 20) {
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }*/

        }
        //isAlive():判断当前线程是否存活
//        System.out.println("当前线程是否存活：" + thread.isAlive());


    }
}

class Window extends Thread {

    private static int ticket = 100;

    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                System.out.println(getName() + "买票编码号为：" + ticket);
                ticket--;
            } else {
                break;
            }
        }
    }
}

public class TicketWindowTest {
    public static void main(String[] args) {
        //创建线程
        Window w1 = new Window();
        Window w2 = new Window();
        Window w3 = new Window();

        //设置线程名字
        w1.setName("窗口一：");
        w2.setName("窗口二：");
        w3.setName("窗口三：");

        //开启线程
        w1.start();
        w2.start();
        w3.start();
    }
}

 1、同步代码块：
    synchronized (对象){
          // 需要被同步的代码；
    }

2、synchronized还可以放在方法声明中，表示整个方法为同步方法。
	例如：
    public synchronized void show (String name){ 
            ….
   }

class Windows02 implements Runnable {

    private int ticke = 100;

    @Override
    public void run() {
        while (true) {
            //使用同步代码方式来解决线程安全问题，this：表示当前对象：【Windows02】
//            synchronized (this) {
//                if (ticke > 0) {
//                    try {
//                        Thread.sleep(100);
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }
//                    System.out.println(Thread.currentThread().getName() + "购票号码为：" + ticke);
//                    ticke--;
//                } else {
//                    break;
//                }
//            }

            show();
        }
    }

    //这里我们直接使用【同步方法】的方式来处理线程安全问题
    //在方法中加入：synchronized的效果等同上面的this，因为指代的都是当前对象，只是在同步方法中帮我们做了隐试操作。
    private synchronized void show() {
        if (ticke > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "购票号码为：" + ticke);
            ticke--;
        }
    }
}

public class TickeWindowTest02 {
    public static void main(String[] args) {
        Windows02 windows = new Windows02();

        Thread thread = new Thread(windows);
        Thread thread01 = new Thread(windows);
        Thread thread02 = new Thread(windows);

        thread.setName("窗口一：");
        thread01.setName("窗口二：");
        thread02.setName("窗口三：");

        thread.start();
        thread01.start();
        thread02.start();


    }
}

//死锁的演示
class A {
    public synchronized void foo(B b) { //同步监视器：A类的对象：a
        System.out.println("当前线程名: " + Thread.currentThread().getName()
                + " 进入了A实例的foo方法"); // ①
//		try {
//			Thread.sleep(200);
//		} catch (InterruptedException ex) {
//			ex.printStackTrace();
//		}
        System.out.println("当前线程名: " + Thread.currentThread().getName()
                + " 企图调用B实例的last方法"); // ③
        b.last();
    }

    public synchronized void last() {//同步监视器：A类的对象：a
        System.out.println("进入了A类的last方法内部");
    }
}

class B {
    public synchronized void bar(A a) {//同步监视器：b
        System.out.println("当前线程名: " + Thread.currentThread().getName()
                + " 进入了B实例的bar方法"); // ②
//		try {
//			Thread.sleep(200);
//		} catch (InterruptedException ex) {
//			ex.printStackTrace();
//		}
        System.out.println("当前线程名: " + Thread.currentThread().getName()
                + " 企图调用A实例的last方法"); // ④
        a.last();
    }

    public synchronized void last() {//同步监视器：b
        System.out.println("进入了B类的last方法内部");
    }
}

public class DeadLock implements Runnable {
    A a = new A();
    B b = new B();

    public void init() {
        Thread.currentThread().setName("主线程");
        // 调用a对象的foo方法
        a.foo(b);
        System.out.println("进入了主线程之后");
    }

    public void run() {
        Thread.currentThread().setName("副线程");
        // 调用b对象的bar方法
        b.bar(a);
        System.out.println("进入了副线程之后");
    }

    public static void main(String[] args) {
        DeadLock dl = new DeadLock();
        new Thread(dl).start();
        dl.init();
    }
}

class Number implements Runnable {
    private int number = 1;
    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                //因为现在使用的是当前对象，所以前面省略this.
                //如果使用的是其他对象，那么就用对象.的方式去调用该方法
                notify();
                if (number <= 100) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " ：" + "打印数为" + number);
                    number++;
                    try {
                        //调用该方法时，线程进入阻塞状态
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }
}
public class CommunicationTest {
    public static void main(String[] args) {
        Number number = new Number();
        Thread thread = new Thread(number);
        Thread thread01 = new Thread(number);
        thread.setName("线程一");
        thread01.setName("线程二");

        thread.start();
        thread01.start();
    }
}

//1.创建一个实现Callable的实现类
class NumThread implements Callable<Integer> {
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}


public class ThreadNew {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask<Integer> futureTask = new FutureTask<Integer>(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();

        try {
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Integer sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

class NumberThread implements Runnable{

    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

class NumberThread1 implements Runnable{

    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

public class ThreadPool {

    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //设置线程池的属性
//        System.out.println(service.getClass());
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();


        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());//适合适用于Runnable

//        service.submit(Callable callable);//适合使用于Callable
        //3.关闭连接池
        service.shutdown();
    }

}