IDEA的使用与多线程

IDEA下载地址：https://www.jetbrains.com/idea/download/#section=windows

多线程

程序：为了完成特定任务，用某种程序语言编写的一组指令的集合
进程: 正在运行的一个程序，运行的qq，mp3等
线程：是一个程序内部的一条执行路径 我玩qq的时候可以开启微信等程序，win10操作系统是多线程的

创建线程的方式1

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

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

public class ThreadTest {
    public static void main(String[] args) {
        //创建Thread类的子类的对象
       MyThread t1;
       t1 = new MyThread();
       MyThread t2;
       t2 = new MyThread();
        //通过此对象调用start()方法：①启动当前线程 ②调用当前线程的run()
        t1.start();
        //问题1：t1.run(); 调用run()方法就没有线程的交互，此方法不能启动线程
        //问题2：再启动一个线程 t1.start(); 不可以让已经start()的线程再执行
        t2.start();//需要重新创建一个线程对象
        //如下操作仍在main中执行
        for (int i = 0; i < 100; i++) {
            if(i%2==0){
                System.out.println(i+"*main*");
            }
        }
    }
  }

/**

* 练习：创建两个分线程，一个线程遍历100以内的偶数，另外一个线程遍历100以内
*      的奇数
* @author shkstart
* @create 2021-04-19-18:40
*/

class  MyThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+": "+i);
            }
        }
    }
}
class MyThread2 extends  Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i%2 != 0){
                System.out.println(Thread.currentThread().getName()+": "+i);
            }
        }
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        MyThread1  t1;
        t1 = new MyThread1();
        MyThread2 t2;
        t2 = new MyThread2();
        t1.start();
        t2.start();//可以看到控制台的交互输出，每次运行输出均不一样。（与CPU有关）

        //创建Thread类的匿名子类的方式
        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();
    }
}

Thread类中的常用方法

/**
*测试Thread类中的常用方法
* 1.start()：启动当前线程，调用当前线程的run()方法
* 2.run()：通常需要重写此方法，将线程执行的操作声明在此方法内
* 3.currentThread()：静态方法，返回执行当前代码的线程
* 4.getName()：获取当前线程的名字
* 5.setName()：设置当前线程的名字  构造器实例化起名字也可
* 6.yield()：释放当前cpu的执行权
* 7.join()：在线程A中调用线程B的join()方法，此时线程A进入阻塞状态，直到
*          线程B完全执行完之后，线程A结束阻塞状态。
* 8.stop()：强制结束当前线程，不建议使用
* 9.sleep(Long millitime)：调用此线程的线程休眠millitime毫秒
* 10.isAlive：判断当前线程是否存活 返回true存活，返回false线程已结束
*
* 线程的优先级：
* 1.三个常量
* MAX_PRIORITY:10
* MIN_PRIORITY:1
* NORM_PRIORITY:5
* 2.如何获取和设置当前线程的优先级：
* getPriority();获取优先级
* setPriority();设置优先级
*      >说明:高优先级线程要抢占低优先级线程的CPU的执行权，但是只是在
*           概率上来讲，并不代表高优先级线程执行完后才执行低优先级的线程
* @author shkstart
* @create 2021-04-19-18:55
*/
class HelloThread  extends  Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i%2==0){
                try {
                    sleep(1);//单位是ms
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+Thread.currentThread().getPriority()+" "+i);
            }
            if(i%20==0){
                this.yield();
            }
        }
    }
    public HelloThread(){
    }
    public HelloThread(String name){
        super(name);
    }
}
public class ThreadMethodTest {
    public static void main(String[] args) {
        HelloThread h1;
        h1 = new HelloThread("Thread1:");
        //h1.setName("线程1 ： ");
        
        //设置分线程的优先级
        h1.setPriority(Thread.MAX_PRIORITY);//
        h1.start();

        //给主线程命名
        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);
            }
            if(i==20){
                try {
                    h1.join();//h1线程执行完才会调用别的线程
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println(h1.isAlive());
    }
    }

/**
*
* 例子： 创建三个窗口买票，总票数为100张
*  存在线程安全问题，待解决
*
* @author shkstart
* @create 2021-04-19-19:40
*/

class Window extends Thread{
    private static int ticket = 100;


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


public class WindowTest {
    public static void main(String[] args) {
        Window w1 = new Window();
        Window w2 = new Window();
        Window w3 = new Window();


        w1.setName("Window 1 ");
        w2.setName("Window 2");
        w3.setName("Window 3");
        w1.start();
        w2.start();
        w3.start();
    }
}

创建线程的方式2

/**
*
* 例子： 创建三个窗口买票，总票数为100张
*使用实现Runnable接口的方式
*仍然存在线程的安全问题，暂时忽略
* @author shkstart
* @create 2021-04-19-19:40
*/

class Window implements Runnable{
    private  int ticket = 100;


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

public class WindowTest {
    public static void main(String[] args) {
        Window window = new Window();//三个线程公用一个window，ticket不同加static
        Thread t1 = new Thread(window);
        Thread t2 = new Thread(window);
        Thread t3 = new Thread(window);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

比较两种创建线程的方式

开发中，优先使用Runnable接口的方式
原因 ：
1.实现的方式没有类的单继承性的局限性
2.实现的方式更适合来处理多个线程共享数据的情况
联系：
public class Thread implements Runnable
相同点：都需要重写run()，将线程要执行的逻辑声明在此方法内

解决多线程的安全问题

/**
*
* 例子： 创建三个窗口买票，总票数为100张
*使用实现Runnable接口的方式
*
* 1.问题：买票过程中出现了重票和错票-->出现了线程的安全问题
* 2.原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程也参与了
*         操作车票的过程
*         上厕所还没上完，另外的人也进来上厕所
* 3.解决：当一个线程在操作ticket的时候，其他的线程不能参与进来，直到
*         此线程操作完，其他线程才可以操作ticket，这种情况即使此线程
*         出现了阻塞，也不能被改变
* 4.在Java照中通过 同步机制 来解决线程的安全问题
*
*      方式一：同步代码块
*      synchronized(同步监视器){
*         // 需要被同步的代码
*      }
*        说明：1.操作共享数据的代码，即为需要被同步的代码 -->不能包含代码多了或少了
*             2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据
*             3.同步监视器，俗称“锁”，任何一个类的对象均可充当 锁
*                  要求：多个线程必须共用同一把锁
*
*        补充：在使用Runnable接口创建多线程的方式中，可以考虑使用this充当同步监视器
*             在继承Thread类创建多线程的方式中，可以考虑使用当前类充当同步监视器
*
*      方式二：同步方法
*      如果操作共享数据的代码完整的声明在一个方法中，可以将此方法声明为同步的
*      总结：1.同步方法仍然涉及到同步监视器，只是不需要显式的声明
*           2.非静态的同步方法，同步监视器仍为 this
*             静态的同步方法，同步监视器是 当前类本身
*
*
* 5.同步的方式，解决了线程的安全问题，但是操作同步代码时只有一个线程操作，效率低
*
* @author shkstart
* @create 2021-04-19-19:40
*/
//Runnable 同步监视器
class Window implements Runnable{
    private  int ticket = 100;
   // Object obj = new Object();
    @Override
    public void run() {
        //Object obj = new Object();
        //不能放在这，run方法在Thread类内，t1-3均使用了自己的obj，不是共用
        while (true){
            //synchronized (obj){
             synchronized (this){
            if(ticket>0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " :买票，票号为： "+ ticket);
                ticket--;
            }else{
                break;
            }
                }
        }
    }
}

public class WindowTest {
    public static void main(String[] args) {
        Window window = new Window();//三个线程公用一个window，ticket不同加static
        Thread t1 = new Thread(window);
        Thread t2 = new Thread(window);
        Thread t3 = new Thread(window);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

//继承Thread 同步监视器
class Window2 extends Thread{
    private static int ticket = 100;
   // private static Object obj = new Object();
    @Override
    public void run() {
        while (true){
            //synchronized (obj){
            synchronized (Window2.class){
            if(ticket>0){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " :买票，票号为： "+ ticket);
                ticket--;
            }else{
                break;
            }
            }
        }

    }
}
public class WindowTest2 {
    public static void main(String[] args) {
        Window2 w1 = new Window2();
        Window2 w2 = new Window2();
        Window2 w3 = new Window2();
        w1.setName("Window 1 ");
        w2.setName("Window 2");
        w3.setName("Window 3");
        w1.start();
        w2.start();
        w3.start();
    }
}

//Runnable 同步方法
/**
* @author shkstart
* @create 2021-04-21-17:21
*/
class Window3 implements Runnable{
    private  int ticket = 100;
    @Override
    public void run() {
        while (true){
            show();
        }
    }
    private synchronized void show(){
        if(ticket>0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " :买票，票号为： "+ ticket);
            ticket--;
        }
    }
}

public class WindowTest3 {
    public static void main(String[] args) {
        Window3 window = new Window3();//三个线程公用一个window，ticket不同加static
        Thread t1 = new Thread(window);
        Thread t2 = new Thread(window);
        Thread t3 = new Thread(window);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

//继承Thread类 同步方法
/**
* 使用同步方法解决继承Thread类的方式创建多线程的线程安全问题
* @author shkstart
* @create 2021-04-21-17:28
*/
class Window4 extends Thread{
    private static int ticket = 100;
   
    @Override
    public void run() {
        while (true){
            show();
        }

    }
    private  static synchronized void show(){
        if(ticket>0){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " :买票，票号为： "+ ticket);
            ticket--;
        }
    }
}

public class WindowTest4 {
    public static void main(String[] args) {
        Window4 w1 = new Window4();
        Window4 w2 = new Window4();
        Window4 w3 = new Window4();
        w1.setName("Window 1 ");
        w2.setName("Window 2");
        w3.setName("Window 3");
        w1.start();
        w2.start();
        w3.start();
    }
}

死锁

/**
* 演式线程的死锁问题
* 1.死锁的理解：不同的线程分别占用对方需要的资源不放弃，都在等待对方放弃自己需要
*              的同步资源，形成了线程的死锁
* 2.说明:
* 1.出现死锁，不会出现异常，也不会出现提示，所有线程处于阻塞状态
* 2.使用同步时，需要避免死锁
* @author shkstart
* @create 2021-04-21-17:55
*/
public class ThreadTest {
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer();
        StringBuffer s2= new StringBuffer();


      new Thread(){
          @Override
          public void run() {
    synchronized (s1){
    s1.append("a");
    s2.append("1");
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (s2){
        s1.append("b");
        s2.append("2");
        System.out.println(s1);
        System.out.println(s2);
    }
}
          }
      }.start();


     new Thread(new Runnable() {
         @Override
         public void run() {
             synchronized (s2){
                 s1.append("c");
                 s2.append("3");
             synchronized (s1){
                     s1.append("d");
                     s2.append("4");
                     System.out.println(s1);
                     System.out.println(s2);
                 }
             }
         }
     }).start();
    }

    }

创建线程的方式3：实现Callable接口

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;


/**
* 创建线程的方式三：实现  Callable 接口
*
*
* 如何理解实现Callable接口的方式创建多线程比实现Runnable接口更强大？
* 1.call()可以有返回值
* 2.call()可以抛出异常，被外面的操作捕获，获取异常信息
* 3.Callable支持泛型
* @author shkstart
* @create 2021-04-22-11:36
*/

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


            }


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


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

创建线程的方式4：线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;


/**
* 创建线程的方式4：使用线程池
* 好处：
* 1.减少了创建新线程的时间
* 2.降低资源消耗，重复利用线程池中的线程，不需要每次都创建
* 3.便于线程管理
* corePoolSize: 核心池的大小
* maximumPoolSize:最大线程数
* keepAliveTime:线程没有任务时最多保持多长时间后终止
* @author shkstart
* @create 2021-04-22-12:03
*/

class NumberThread implements Runnable{


    @Override
    public void run() {
        for (int i = 1; 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 = 1; 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 executorService = Executors.newFixedThreadPool(10);


        //设置线程池的一些属性
        ThreadPoolExecutor executorService1 = (ThreadPoolExecutor) executorService;
        System.out.println(executorService.getClass());


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




        //3.关闭连接池
        executorService.shutdown();
    }
}