何为程序?何为进程?何为线程?

何为程序?
为完成某个任务、用某种语言编写的一组指令的集合。即一段静态的代码,静态对象。
何为进程?
程序的一次执行过程,或是正在运行的一个程序。是一个动态的过。有它自身的产生、存在和消亡的过程(即生命周期)
进程是资源分配的单位,系统在运行时会为每个进程分配不同的内存区域。(即独立的堆和方法区)
何为线程?
进程的进一步细化,是一个程序内部的一条执行路径。
线程是执行和调度的单位,每个线程拥有独立的运行栈和程序计数器(pc),线程切换的开销较小。

多线程的四种创建方式

创建多线程方式一:继承于 Thread类

步骤:

  1. 创建一个继承于Thread类的子类
  2. 重写Thread类的run() --->将此线程执行的操作声明在 run()方法中
  3. 创建Thread类子类的对象
  4. 通过此对象调用start()
    作用: ① 启动当前线程 ② 调用当前线程的 run()方法
/**
*    需求:利用多线程输出 1~100之间的所有偶数
*/

//1、创建一个继承于Thread类的子类
class MyThread extends Thread{

    //2、重写 Thread类中得 run()方法
    @Override
    public void run() {
        for (int i=1;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类的子类的对象
        MyThread s = new MyThread();

        //4、调用 Thread类中的start()方法:
        s.start();
        
        //问题一:不能通过直接调用run()来启动线程
        //s.run();



        //问题二:再启动一个线程遍历100以内的偶数,需要重新创造一个新的对象,再调用 strat()方法
        MyThread s1 = new MyThread();
        s1.start();

        //以下操作仍然是在main()线程中执行的。
        for (int i=1;i<100;i++){
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+i+"*****main()*****");
            }
        }
    }
}

多线程中常用的方法

1、start()启动当前线程,调用当前线程的 run()方法
2、run():通常需要重写 Thread类中得此方法,将创建的线程要执行的操作声明在此方法中
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():判断当前线程是否存活

/**
 * 线程的优先级:
 * 1、MAX_PRIORITY:10
 *    MIN_PRIORITY:1
 *    NORM_PRIORITY 5  --->默认优先级
 *
 * 2、如何设置优先级和获取优先级:
 *         getPriority():获取当线程的优先级
 *         setPriority():设置当前线程的优先级
 *
 * 说明:高优先级的线程要抢占低优先级的线程的CPU的执行权,但是从概率上来讲,高优先级的线程高概率的情况下优先被执行,
 *      但并不意味着高优先级的线程执行完以后,低优先级的线程再执行。
 *
 */
public class ThreadMethod {

    public static void main(String[] args) {
        Method m = new Method("Method线程:1");
        //m.setName("Method线程:");

        //给分线程设置优先级
        m.setPriority(Thread.MAX_PRIORITY);
        m.start();


        //给主线程命名
       Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
        Thread.currentThread().setName("main线程:");
        for (int i=1;i<100;i++){
            if (i % 2 ==0){

                /*try {   //用来设置每隔 1s执行一次
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }*/
                System.out.println(Thread.currentThread().getName()+i);
            }

            /*if (i == 20){
                try {
                    m.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }*/
        }

        //System.out.println(m.isAlive()); //输出线程是否“存活”,存活输出true,反之返回false
    }
}



class Method extends Thread{
    public Method(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i=1;i<100;i++){
            if (i % 2 !=0) {
                /*try {
                    sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }*/
                System.out.println(Thread.currentThread().getName()+i);
            }


            /*if (i % 21 ==0){
                yield(); // Thread.currentThread().yield()
                        // 和   this.yield() 的省略版,这里的 this 指代当前类的对象
            }*/
        }
    }
}

创建多线程方式二:实现 Runnable接口

步骤:

  1. 创建一个实现类实现接口Runnable
  2. 重写接口中得 run() 方法 --->将此线程执行的操作声明在 run()方法中
  3. 创建实现类的对象
  4. 将实现类的对象作为参数传给 Thread类的构造器,创建 Thread类的对象
  5. 通过 Thread类的对象调用 start()
/** 
*  需求:输出 1~100之间的偶数 
*/

public class ThreadTest1 {
    public static void main(String[] args) {
        //3、创建实现类的对象
        MThread m = new MThread();
        
        //4、通过Thread类的构造器创建 参数为实现类对象 的 Thread类的对象
        Thread t1 = new Thread(m);
        t1.setName("Thread1:");

        //5、通过Thread类的对象调用start()
        t1.start();



        Thread t2 = new Thread(m);
        t2.setName("Thread2:");
        t2.start();
    }
}


//1、创建实现类实现接口Runnable
class MThread implements Runnable {

    //2、重写接口中的run()
    @Override
    public void run() {
        for (int i=1;i<100;i++){
            if (i % 2 ==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

补充:
在开发中,继承Thread类 和 实现Runnable接口两种方式,
优先选择: 实现 Runnable 接口方法。
原因:
1、实现的方式没有单继承的局限性
2、实现方式更适合来处理共享数据

Thread 和 Runnable 的联系:

  1. public class Thread implements Runnable
  2. 都要重写 run(),同时把线程要执行的代码声明再run()方法体中

创建方式三:实现接口Callable (JDK 5.0 中新增方式)

步骤:

  1. 创建实现 Callable接口 的实现类
  2. 实现 call() 方法 --->将此线程执行的操作声明在 call()方法中
  3. 创建 Callable 实现类的对象
  4. 将 Callable 实现类的对象作为参数,通过 FutureTask 类的构造器创建 FutureTask 类的对象
  5. 将 FutureTask 类的对象作为参数,通过 Thread 类的构造器创建 Thread 类的对象,并通过Thread类的对象调用 start() 启动该线程
  6. 获取 Callable 接口中得 call() 的返回值。(可选)
/**
*    需求:输出 1~100之间的所有偶数,并求所有偶数的和
*/
//1、创建实现 Callable接口 的实现类
class NumThread implements Callable {
    private int sum = 0;

    //2、实现 call()方法
    @Override
    public Object call() throws Exception {
        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 n = new NumThread();

        //4、将Callable 实现类的对象作为参数,通过 FutureTask类的构造器创建 FutureTask 的对象
        FutureTask futureTask = new FutureTask(n);


        //5、将 FutureTask类 的对象作为参数,通过Thread类的构造器创建 Thread类的对象,并调用 start()启动该线程
        new Thread(futureTask).start();


        try {
            //6、获取 Callable实现类 中得 call() 的返回值
            //此处的 get()方法的返回值即为
            //FutureTask构造器参数 Callable 实现类的对象中得 call()方法的返回值
            Object o = futureTask.get();
            System.out.println("1-100之间的所有偶数的和为:" + o);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

实现 Callable 接口 比实现 Runnable 接口强大:
1、call() 可以有返回值
2、call() 可以抛出异常,被外面的操作捕获,获取异常信息
3、Callable 是支持泛型的。

创建方式四:线程池(JDK 5.0 中新增方式)


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

        //提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor sevice1 = (ThreadPoolExecutor) service;



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



        //设置线程池的属性
        //System.out.println(service.getClass());//获取当前对象所属的类
        sevice1.setCorePoolSize(15);    //设置线程池的大小



        //service.submit(Callable callable ) //适合使用于Callable

        //关闭线程池
        service.shutdown();
    }
}


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 NumberThread2 implements Runnable {

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {

            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

使用线程池的好处

  1. 提高响应速度(减少了创建新线程的时间)
  2. 降低资源消耗(重复利用线程池中线程,不需要每次都创建)
  3. 便于线程管理:

     corePoolSize:核心池的大小
     maxmumPoolsize:最大线程数
     heepAliveTime:线程没有任务时,最多保持多长时间后会终止
    

多线程的三种处理线程安全问题(即同步)

处理方式一:同步代码块

    synchronized(同步监视器){
           //需要被同步的代码
       }
/** 处理方式一:同步代码块
 *
 *      synchronized(同步监视器){
 *          //需要被同步的代码
 *      }
 *
 *      说明:1、操作共享数据的代码,即为需要被同步的代码     ---->不能包含代码多了,也不能包含少了
 *           2、共享数据:多个线程共同操作的变量,比如:ticket 就是共享数据
 *           3、同步监视器,俗称:锁。任何一个类的对象,都可以充当锁。
 *
 *              要求:多个线程必须要共用同一把锁
 *
 *           4、补充:在实现 Runnable接口创建多线程方式中,可以考虑使用 this 充当同步监视器
 *
 *
 *             5、同步的方式,解决了线程的安全问题。 ---好处
 *               操作同步代码块时,只能一个线程操作,其他线程等待,相当于一个单线程,效率低。 ---坏处
 *    
 *        
 *    
 *    需求:创建三个窗口买票,总票数为 100。
 *        
 * @author Herz
 * @date 2021/3/8 15:30
 */
public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w1 = new Window1();

        Thread t1 = new Thread(w1);
        t1.setName("窗口 1");
        t1.start();

        Thread t2 = new Thread(w1);
        t2.setName("窗口 2");
        t2.start();

        Thread t3 = new Thread(w1);
        t3.setName("窗口 3");
        t3.start();
    }
}


class Window1 implements Runnable{

    private  int ticket = 100;

    //Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (this) {//这里的this 指代的是当前类的对象也就是 w 对象
                                    //方式二: synchronized (obj)
                if (ticket > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "买票,票号为:" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

处理方式二:同步方法

用 synchronized 修饰该操作方法

说明:
1、同步方法任然涉及到同步监视器,只是不用显示声明
2、非静态同步方法中,同步监视器是:this
静态同步方法中,同步监视器是:当前类本身

/**
*    处理方式二:使用同步方法解决 实现 Runnable接口创建多线程的方式的线程安全问题
*                (解决继承Thread类创建多线程方式的线程安全问题类似)
*
*     例:创建三个窗口售票,总票数为100张
*/
public class WindowTest11 {
    public static void main(String[] args) {
        Window11 w = new Window11();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口 1");
        t2.setName("窗口 2");
        t3.setName("窗口 3");

        t1.start();
        t2.start();
        t3.start();
    }
}


class Window11 implements Runnable{

    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            show();
        }
    }

    private synchronized void show(){  //同步监视器:this
        if (ticket > 0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"卖票,票号为:"+ticket);
            ticket--;
        }
    }
}

处理方式三:Lock锁(JDK 5.0 新增方式)

/**
*     需求:创建三个窗口售票,总票数为100张
*/
class Window implements Runnable {

    private int ticket = 100;

    //实例化 ReentrantLock 类
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {

                //调用 lock()
                lock.lock();

                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + "卖票,票号为:" + ticket);
                    ticket--;
                } else {
                    break;
                }
            } finally {
                //调用解锁方法:unlock()
                lock.unlock();
            }
        }
    }
}


public class LockTest {
    public static void main(String[] args) {
        Window w = new Window();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口 1");
        t2.setName("窗口 2");
        t3.setName("窗口 3");

        t1.start();
        t2.start();
        t3.start();
    }
}

面试题 synchronized 和 Lock锁 的异同:

同:二者都可以解决线程安全问题
异:synchronized 在执行完相应的同步代码后,自动的释放同步监视器,
Lock 需要手动的启动同步(lock()),同时结束的时候需要手动释放(unlock())。

多线程的通信

涉及到的三个方法:

wait():一旦执行此方法,当前线程就进入阻塞状态,并释放同步监视器。
notify():一旦执行此方法,就会唤醒被wait()的一个线程。如果有多个线程,就唤醒优先级高的那个。
notifyAll():一旦执行此方法,就会唤醒所有被wait()的线程。

说明:

1、wait()、notify()、notifyAll() 三个方法必须使用在同步代码块或同步方法中。
2、wait()、notify()、notifyAll() 三个方法的调用者必须是同步代码块或同步方法中得同步监视器。
否则,会出现 IllegalMonitorStateException 异常。

/**
 *
 * 线程间的通信练习:
 *      使两个线程打印1-100,交替打印
 *
 * @author Herz
 * @date 2021/3/9 21:32
 */
public class CommunicationTest {
    public static void main(String[] args) {
        Communicate c = new Communicate();

        //实例化两个线程
        Thread t1 = new Thread(c);
        Thread t2 = new Thread(c);

        t1.setName("线程 1");
        t2.setName("线程 2");

        t1.start();
        t2.start();
    }
}


class Communicate implements Runnable{

    private int num = 1;
    //private Object obj = new Object();

    @Override
    public void run() {

        while (true){
            //synchronized (obj) {
            synchronized (this){
                this.notify(); //唤醒另外一个线程

                if (num <= 100) {
                    System.out.println(Thread.currentThread().getName() + ":" + num);
                    num++;

                    try {
                        //使得调用如下wait()方法的线程进入阻塞状态
                        this.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }
}

线程的生命周期

Java基础之多线程

多线程的死锁

/**
 *
 * 演示线程的死锁问题:
 *
 *    1、死锁的理解:不同的线程分别占用对方需要的资源不放弃,
 *      都在等待对方放弃自己需要的同步资源,就形成了死锁。
 *
 *
 *    2、说明:
 *       1)出现死锁后,不会出现异常,不会出现提示,只是所有的线程处于阻塞状态,无法继续
 *       2)使用同步时,避免死锁。
 *
 * @author Herz
 * @date 2021/3/9 15:10
 */
public class DeadlockTest {
    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");

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    synchronized (s1){
                        s1.append("d");
                        s2.append("4");

                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }).start();
    }
}