Java实现多线程内容通俗易懂，一篇文章了解多线程并且能到简单的使用多线程

导学了解

什么是进程？

进程：程序的基本执行实体

更加通俗的讲：一个软件执行后，它就是一个进程，绿色的内容都是一个进程。

什么是线程？

线程是操作系统能够进行运算调度的最小单位。它被包含在进程当中，是进程中的实际运作单位。

可以这样理解：用没有用过360安全卫士，它上面的每个功能都相当于进程，很多进程能够同时的运行，并且互相没有产生问题。进程类似于应用中互相独立，可以同时运行的功能。很多的线程合在一起就形成了多线程。

什么是多线程？

Java多线程是指在Java程序中同时运行多个线程，每个线程都可以独立执行不同的任务。Java多线程可以提高程序的并发性和响应性，使得程序可以同时处理多个任务，提高程序的效率。Java中的多线程可以通过继承Thread类或实现Runnable接口来创建线程，也可以使用线程池来管理线程。同时，Java提供了丰富的多线程API，如synchronized关键字、wait()和notify()方法等，来帮助开发者更好地控制线程的并发访问。

实现多线程的三种方式：

方法一：继承Thread类：

通过重写父类Thread方法中的run方法实现线程

注意：线程的开启是通过使用start方法来开启线程，而并非是通过使用调用run方法，通过类的对象去调用run方法，只能是一个普通的调用，并不能开启线程。

代码实现：

package thread_study;

public class demo1 {
    public static void main(String[] args) {
        MyThread1 thread = new MyThread1();
        MyThread1 thread2 = new MyThread1();
        thread.setName("线程一");
        thread2.setName("线程而");
        //注意：这里的线程开发则是通过start方法去开启，并非是通过调用run方法，调用run方法则是普通的调用
        thread.start();
        thread2.start();

    }
}
class MyThread1 extends Thread{
    /*
        开启线程的第一种方法：
        定义个类去继承线程类Thread
        重写类中的run方法
        创建子类的对象，并且去开启线程
     */
    @Override
    public void run() {
        for (int i=0;i<10;i++){
            System.out.println("这是"+getName()+"的内容输出");
        }
    }
}

控制台输出：

方法二：通过实现Runnable接口

代码实现

package thread_study;

public class demo2 {
    public static void main(String[] args) {
        MyThread2 myThread2 = new MyThread2();
        Thread thread = new Thread(myThread2);
        Thread thread2 = new Thread(myThread2);
        thread.setName("线程一");
        thread2.setName("线程二");
        thread.start();
        thread2.start();

    }
}
class MyThread2 implements Runnable{
    /*
        开启线程的第二种方法：
        定义个类实现R
        重写类中的run方法
        创建子类的对象，并且去开启线程
     */
    @Override
    public void run() {
        for (int i=0;i<10;i++){
//            Thread thread = Thread.currentThread();
            System.out.println("这是"+Thread.currentThread().getName()+"的内容输出");
        }
    }
}

方法三：继承Callable

注意:这个方法拥有返回值

package thread_study;

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

//第三种方法去实现线程
public class MyThread3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        /*
            多线程实现的第三种方法：可以接收到线程运行的结果
            通过实现Callable接口，重写call方法
            然后通过创建FutureTask对象（通过此类可以实现对多线程运行结果的管理
         */
        MyThread_test myThread_test = new MyThread_test();
        FutureTask<Integer> futureTask  = new FutureTask<>(myThread_test);
        Thread thread = new Thread(futureTask);
        thread.start();
        System.out.println(futureTask.get());

    }

}
class MyThread_test implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        int sum=0;
        for (int i = 0; i <= 100; i++) {
            sum =sum +i;
        }
        return sum;
    }
}

多线程常用的方法讲解

setPriorit(int 值)：设置优先级

可以设置线程的优先顺序，优先级高的线程会优先去执行，但是这种方法的设置，并不意味着优先级高的一定比优先级底的先执行完，因为在线程执行是抢占式，谁先抢到谁先去执行，所以说优先级高的并不是一定的比线程优先级低的先行执行完成。

代码实现：

设置：线程二的优先级比线程的一的优先级高

package thread_study;

public class MyThread04 {
    public static void main(String[] args) {
        Thread04_test thread04_test= new Thread04_test();
        Thread thread = new Thread(thread04_test,"线程一");
        Thread thread2 = new Thread(thread04_test,"线程二");
        //获取当前线程的优先级
//        System.out.println(Thread.currentThread().getPriority());
        //设置进程的优先级默认为5 1最小 10最大
        thread.setPriority(1);
        thread2.setPriority(10);
        thread.start();
        thread2.start();
    }
}
class Thread04_test implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"@"+i);
        }
    }
}
/*
* 线程优先级低的可能比优先级的高的线程先行执行完，只是这中的概率比较低，但是还是有一种概率发生。如果不进行任何的设置，那么这个线程的默认优先级数值为5
*
* */

运行结果：

大概率的情况下：线程二先行执行完，然后线程一再执行完

小概率的情况下：线程二后执行完，线程一先行执行完

守护线程

守护线程：可以理解为当一个线程结束时，守护线程也会陆续的结束，qq聊天界面，有着聊天和传输文件的功能，聊天是一个线程，传输文件也是一个线程，但是当一个qq聊天界面关闭时，那么传输文件的哪个界面，也就关闭了 * 守护线程当线程结束时，那么守护线程则没有没有存在的必要了，但是它不会立刻的结束，他会慢慢的结束。

案例实现线程二对线程一的守护，当线程一结束时，他的守护线程二也会陆陆续续的停掉

代码实现：

package thread_study;

public class MyThread05 {
    public static void main(String[] args) {
        /*
        *   守护线程：可以理解为当一个线程结束时，守护线程也会陆续的结束
        *   qq聊天界面，同时聊天和传输文件，聊天是一个线程，传输文件也是一个线程，但是当一个qq聊天界面关闭时，那么传输文件的哪个界面，也就关闭了
        *   守护线程当线程结束时，那么守护线程则没有没有存在的必要了，但是它不会立刻的结束，他会慢慢的结束
        *
        * */
        //案例实现线程二对线程一的守护，当线程一结束时，他的守护线程二也会陆陆续续的停掉
        Thread05_demo1 thread05_demo1 = new Thread05_demo1();
        Thread05_demo2 thread05_demo2 = new Thread05_demo2();

        thread05_demo1.setName("线程一");
        thread05_demo2.setName("线程二");
        //把线程二设置成守护线程
        thread05_demo2.setDaemon(true);

        thread05_demo1.start();
        thread05_demo2.start();
    }
}

class Thread05_demo1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName()+"@"+i);
        }
    }
}
class Thread05_demo2 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+"@"+i);
        }
    }
}

运行结果：

线程二守护线程一，当线程一执行完之后，线程二就陆陆续续的结束，并不能直接的结束

yield()出让线程

出让线程：Java的线程时抢占式，多线程过程中，谁先抢到线程，谁就会先执行 *

也可以通过yield出让本线程的执行权，出让执行权，但是出让这个机会，出让执行权的线程依旧可以再次的抢夺，可以通过此方法实现尽可能的均匀 *

静态方法，可以通过类去直接的调用

代码实现

package thread_study;

public class MyThread06 {
    public static void main(String[] args) {
        /*
        * 出让线程：Java的线程时抢占式，多线程过程中，谁先抢到线程，谁就会先执行
        * 也可以通过yield出让本线程的执行权，出让执行权，但是出让这个机会，出让执行权的线程依旧可以再次的抢夺，可以通过此方法实现尽可能的均匀
        * 静态方法，可以通过类去直接的调用
        * */
        MyThread06_test myThread06_test1 = new MyThread06_test();
        MyThread06_test myThread06_test2 = new MyThread06_test();

        myThread06_test1.setName("线程一");
        myThread06_test2.setName("线程二");

        myThread06_test1.start();
        myThread06_test2.start();
    }
}

class MyThread06_test extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+"@"+i);
            //出让当前CPU的执行权
            Thread.yield();
        }
    }
}

join方法：实现线程的插入（通俗的讲就是插队）

插入线程，在一个线程的前面，在插入一个线程

通过join方法来实现

main方法默认的情况下也是一个程序

在main方法去执行程序，然后再通过join方法去再main方法前添加一个程序

代码实现

package thread_study;

public class MyThread07 {
    public static void main(String[] args) throws InterruptedException {
        /*
            插入线程，在一个线程的前面，在插入一个线程
            通过join方法来实现
            main方法默认的情况下也是一个程序
            在main方法去执行程序，然后再通过join方法去再main方法前添加一个程序
        * */
//      通过join方法实现MyThread07_test线程的插入
        MyThread07_test myThread07_test = new MyThread07_test();
        myThread07_test.setName("线程");
        myThread07_test.start();
        myThread07_test.join();
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+i);
        }
    }

}

class MyThread07_test extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+"@"+i);
        }
    }
}

运行结果

线程插队成功

锁：synchronized

//同步代码块

//给线程添加一个锁，保证的是只有一个线程去执行，当代码完全执行完毕后，再释放锁，不会出现数据的重复，和超出范围值

//注意锁的对象必须是唯一的，可以通过字节码对象，因为带idea中类的创建必须是唯一的

* 实现三个售票点，正在销售，总共有100张票

* 在正常的开发过程中，几个线程同时执行代码，那么在同一时间而言，就有可能有多个线程去执行同一行代码

* 这样就容易出现代码的重复，还会容易出现，超出范围等问题，锁的产生帮助我们去解决这个问题

代码实现

package thread_study;

public class MyThread08 {

    public static void main(String[] args) {
        /*
        * 实现三个售票点，正在销售，总共有100张票
        * 在正常的开发过程中，几个线程同时执行代码，那么在同一时间而言，就有可能有多个线程去执行同一行代码
        * 这样就容易出现代码的重复，还会容易出现，超出范围等问题，锁的产生帮助我们去解决这个问题
        * */

        MyThread08_test myThread08_test1 = new MyThread08_test();
        MyThread08_test myThread08_test2 = new MyThread08_test();
        MyThread08_test myThread08_test3 = new MyThread08_test();

        myThread08_test1.setName("售票点一");
        myThread08_test2.setName("售票点二");
        myThread08_test3.setName("售票点三");

        myThread08_test1.start();
        myThread08_test2.start();
        myThread08_test3.start();

    }


}

class MyThread08_test extends Thread{
    static int ticket = 1;
    @Override
    public void run() {
        while (true){
            //同步代码块
            //给线程添加一个锁，保证的是只有一个线程去执行，当代码完全执行完毕后，再释放锁，不会出现数据的重复，和超出范围值
            //注意锁的对象必须是唯一的，可以通过字节码对象，因为带idea中类的创建必须是唯一的
            synchronized (MyThread08_test.class){
                if(ticket<=100){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(getName() + "正在卖第"+ticket +"票");
                    ticket ++;
                }else {
                    break;
                }
            }
        }
    }
}

输出结果：

把synchronized关键字定义在方法上如何的实现

代码实现

package thread_study;

public class MyThread09 {
    public static void main(String[] args) {
        MyThread09_test myThread09_test = new MyThread09_test();
        Thread thread1 = new Thread(myThread09_test);
        Thread thread2 = new Thread(myThread09_test);
        Thread thread3 = new Thread(myThread09_test);

        thread1.setName("窗口一");
        thread2.setName("窗口二");
        thread3.setName("窗口三");

        thread1.start();
        thread2.start();
        thread3.start();
    }

}

class MyThread09_test implements Runnable{
    int ticket = 1;

    @Override
    public void run() {
        while (true){
            try {
                if (demo1()) break;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private synchronized boolean demo1() throws InterruptedException {
        if(ticket>100){
            return true;
        }else{
            Thread.sleep(100);
            System.out.println(Thread.currentThread().getName() + "正在卖第" +ticket + "票");
            ticket ++;
        }
        return false;
    }
}

锁二:Lock

synchronized：这个上锁是自动化，只要有线程执行了方法，就会上锁，但是只有当方法完全之后，才要释放锁

通过lock来实现，上锁和释放锁，通过我们的手动的方法去上锁和释放锁，并非像synchronized智能锁一样不需要手动的添加。

通过Lock方法实现上一个卖票的案例

package thread_study;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyThread10 {
    public static void main(String[] args) {
        /*
        * synchronized：这个上锁是自动化，只要有线程执行了方法，就会上锁，但是只有当方法完全之后，才要释放锁
        * 通过lock来实现，上锁和释放锁
        * */
        MyThread10_test myThread10_test = new MyThread10_test();
        Thread thread = new Thread(myThread10_test);
        Thread thread2 = new Thread(myThread10_test);
        Thread thread3 = new Thread(myThread10_test);
        thread.setName("线程1");
        thread2.setName("线程2");
        thread3.setName("线程3");
        thread.start();
        thread2.start();
        thread3.start();
    }
}
class MyThread10_test implements Runnable{
    static int ticket = 1;
    static Lock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true){
            //上锁
            lock.lock();
            try {
                if(ticket<=100){
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + "正在卖第"+ticket +"票");
                    ticket ++;

                }else {
                    break;
                }
                
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            finally {   //把释放锁放在finally可以确保，无论如何释放锁都会被执行
                //释放锁
                lock.unlock();
                
            }
        }
    }
    }

等待唤醒机制：生产者和消费者机制

这种模式是一种十分经典的多线程协作方式，它可以让线程结果更加的均匀，假设只有两个线程的情况下，这种机制会线程一实现一次，线程二实现一次，轮流的执行。

案例实现：消费者生产者模式，生产者做出一份，那么消费者就消费一份，如果消费者没有消费完，那么生产者就需要等待，如果生产者没有生产一份，那么消费者就要等待。

代码：

生产者（Cooker）

package wait_notify;

public class Cooker extends Thread {
    @Override
    public void run() {
        while (true) {
            synchronized (Desk.object) {
                if(Desk.count==0){
                    break;
                }else {
                    if(Desk.foodlie==1){
                        try {
                            //生产者等待
                            Desk.object.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }else {
                        System.out.println(getName()+"要开始做饭了。。。");
                        Desk.foodlie=1;
                        //生产者唤醒消费者
                        Desk.object.notifyAll();
                    }
                }
            }
        }
    }
}

消费者：

package wait_notify;

public class foodlie extends Thread {
    @Override
    public void run() {
        while (true){
            synchronized (Desk.object){
                if(Desk.count==0){
                    break;
                }
                else {
                    if (Desk.foodlie==0){
                        try {
                            //消费者等待
                            Desk.object.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    else {
                        Desk.count--;
                        System.out.println(getName()+"开始吃饭"+"还剩下"+Desk.count+"碗");
                        //消费者唤醒生产者
                        Desk.object.notifyAll();
                        Desk.foodlie=0;

                    }
                }
            }
        }
    }
}

控制台：相当于桌子，判断是否有食物

package wait_notify;

public class Desk {
    //定义消费者总共吃多少量
    public static int count =10;

    //定义锁对象
    public static Object object = new Object();

    //定义桌子上是否有食物 o：表示没有 1:表示有食物
    public static int foodlie = 0;
}

测试类：

package wait_notify;

public class Test {
    public static void main(String[] args) {
            foodlie foodlie = new foodlie();
        Cooker cooker =new Cooker();

        foodlie.setName("消费者");
        cooker.setName("厨师");

        foodlie.start();
        cooker.start();
    }
}