Java基础学习(八) - 多线程

理解线程

进程是指一个内存中运行的应用程序，系统运行一个程序即是一个进程从创建，运行，结束的过程。

线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。

多线程的特点是并发执行（同一时间段执行多个任务），实际上并不能提高程序运行速度，但能够提高运行效率，让cpu使用率更高。

关于线程调度，分为分时调度和抢占调度。

• 抢占调度模式，需要设置线程的优先级，优先级别高的线程优先使用cpu。
• 分时调度，所有线程轮流使用cpu，平均分配每个线程占用cpu的时间。

1.Java中的多线程实现

Java中实现多线程有两种方式：

1. 继承Thread类并重写run方法，创建Thread对象执行。
2. 定义Runable接口的实现类，并重写接口的run方法（线程执行体）。Runnable实现类里包含的run()方法仅作为线程执行体，然后传递给Thread对象执行。

实现Runnable接口比继承Thread类所具有的优势：

1.  适合多个相同的程序代码的线程去共享同一个资源。
2. 可以避免java中的单继承的局限性。
3.  增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
4.  线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

构造方法：

• public Thread() :分配一个新的线程对象。
• public Thread(String name) :分配一个指定名字的新的线程对象。
• public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
• public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。

常用方法：

• public String getName() :获取当前线程名称。
• public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
• public void run() :此线程要执行的任务在此处定义代码。
• public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
• public static Thread currentThread() :返回对当前正在执行的线程对象的引用。

下面通过代码来了解执行过程：

//继承Thead实现
class MyThead extends Thread{
    public MyThead(String name){
        super(name);
    }
    @Override
    public void run(){
        System.out.println("我是线程"+getName());
    }
}


public class TestThread {
    public static void main(String[] args){
        //创建线程对象
        MyThead mt = new MyThead("M");
        //开启一个新的线程
        mt.start();
        System.out.println("我是main线程");
    }
}

//实现Runnable，重写run方法
class MyRunable implements Runnable{
    @Override
    public void run(){
        System.out.println("我是线程"+ Thread.currentThread().getName());
    }
}
public class TestRunable {
    public static void main(String[] args){
        //创建 MyRunable对象
        MyRunable mr = new MyRunable();
        //创建线程对象
        Thread t = new Thread(mr,"t");
        //运行线程
        t.start();
        System.out.println("我是main线程");
    }
}

2.线程同步

使用多个线程访问同一资源的时候，并在线程中修改资源，就会出现线程安全问题。

//实现Runnable，重写run方法
class MyRunable implements Runnable{
    private int a = 10;
    @Override
    public void run(){
        while (a > 0){
            
            try{
                Thread.sleep(10);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            a -= 1;
            System.out.println("线程"+Thread.currentThread().getName()+"操作了a，a的值为"+a);
        }

    }
}
public class TestRunable {
    public static void main(String[] args){
        //创建 MyRunable对象
        MyRunable mr = new MyRunable();
        //创建线程对象
        Thread t1 = new Thread(mr,"t1");
        Thread t2 = new Thread(mr,"t2");
        Thread t3 = new Thread(mr,"t3");
        //运行线程
        t1.start();
        t2.start();
        t3.start();

    }
}

由于多个线程操作变量a，导致a的值异常（-1不应该出现）。

线程安全问题都是由于多线程对全局变量进行修改操作引起的，这时就需要使用线程同步。

线程同步原理：

在一个线程操作资源时，其他线程不允许操作，保证数据的同步性。

Java中提供了三种方式来实现线程同步。

• 同步代码块：synchronized 关键字可以用于方法中的某个区块中，为区块代码添加互斥访问。

• 同步方法 :使用synchronized修饰方法。一个线程在执行该方法时，其他线程阻塞。

• Lock 锁：也称同步锁，加锁与释放锁方法化了。

同步代码块：

//实现Runnable，重写run方法
class MyRunable implements Runnable{
    private int a = 10;
    //同步锁
    Object lock = new Object();
    @Override
    public void run(){
        while (true){
            synchronized (lock){
                if (a > 0){
                    try{
                        Thread.sleep(50);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                    a -= 1;
                    System.out.println("线程"+Thread.currentThread().getName()+"操作了a，a的值为"+a);

                }

            }
        }
    }
}
public class TestRunable {
    public static void main(String[] args){
        //创建 MyRunable对象
        MyRunable mr = new MyRunable();
        //创建线程对象
        Thread t1 = new Thread(mr,"t1");
        Thread t2 = new Thread(mr,"t2");
        Thread t3 = new Thread(mr,"t3");
        //运行线程
        t1.start();
        t2.start();
        t3.start();

    }
}

同步方法:

//实现Runnable，重写run方法
class MyRunable implements Runnable{
    private int a = 10;
    @Override
    public void run(){
        while (true) {
            method1();
        }
    }
    //同步方法
    public synchronized void method1(){
        if (a > 0){
            try{
                Thread.sleep(50);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            a -= 1;
            System.out.println("线程"+Thread.currentThread().getName()+"操作了a，a的值为"+a);

        }
    }
}
public class TestRunable {
    public static void main(String[] args){
        //创建 MyRunable对象
        MyRunable mr = new MyRunable();
        //创建线程对象
        Thread t1 = new Thread(mr,"t1");
        Thread t2 = new Thread(mr,"t2");
        Thread t3 = new Thread(mr,"t3");
        //运行线程
        t1.start();
        t2.start();
        t3.start();

    }
}

Lock锁包含两个方法：

• public void lock() :加同步锁。
• public void unlock() :释放同步锁。

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

//实现Runnable，重写run方法
class MyRunable implements Runnable{
    private int a = 10;
    //同步锁
    Lock lock = new ReentrantLock();
    @Override
    public void run(){
        while (true){
            //加锁
            lock.lock();
            if (a > 0){
                try{
                    Thread.sleep(20);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                a -= 1;
                System.out.println("线程"+Thread.currentThread().getName()+"操作了a，a的值为"+a);

            }
            //释放锁
            lock.unlock();
        }
    }
}
public class TestRunable {
    public static void main(String[] args){
        //创建 MyRunable对象
        MyRunable mr = new MyRunable();
        //创建线程对象
        Thread t1 = new Thread(mr,"t1");
        Thread t2 = new Thread(mr,"t2");
        Thread t3 = new Thread(mr,"t3");
        //运行线程
        t1.start();
        t2.start();
        t3.start();

    }
}

3.线程状态

• NEW：线程创建未启动。
• Runnable：可运行。
• Blocked：锁阻塞。当一个线程获得同步锁时，其他线程会被阻塞，直到获得同步锁。
• Waiting：无限等待。当一个线程进入Waiting状态后，会无限等待，直到其他线程调用notify或者notifyAll方法唤醒（线程通信）。
• TimedWaiting：计时等待。当一个线程调用sleep方法时，程序会进入计时等待，直到时间结束。

• Teminated：被终止。run方法未正常退出而死亡。

温馨提示

• 如果您对本文有疑问，请在评论部分留言，我会在最短时间回复。
• 如果本文帮助了您，也请评论关注，作为对我的一份鼓励。
• 如果您感觉我写的有问题，也请批评指正，我会尽量修改。