Java基础学习(八)

理解线程

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

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

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

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

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

1.Java中的多线程实现

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

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

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

适合多个相同的程序代码的线程去共享同一个资源。
可以避免java中的单继承的局限性。
增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
线程池只能放入实现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方法未正常退出而死亡。

4.线程通信

多个线程在处理同一资源，但是线程任务却不相同，当我们希望有规律的执行吗，那么线程之间需要一些协调通信。

线程通信的核心是等待唤醒机制。等待唤醒机制是多线程间的一种协作机制，就是一个线程执行wait操作进入无限等待状态，等待其他线程执行 notify 唤醒线程，或者使用 notifyAll 来唤醒所有的等待线程。

等待唤醒方法：

wait：线程进入wait状态，不会去参与调度。
notify：释放所通知对象的一个线程。
nofifyAll：释放所通知对象的全部线程。

唤醒方法使用注意：

wait 和 notify 方法必须要由同一个所对象调用。
两个方法都是属于object类的方法。
两个方法必须要在同步代码块或同步函数中。因为必须要通过锁对象调用这两个方法。

案例：生产者与消费者模型。

class BaoZi {

    boolean flag = false ;//包子资源 是否存在 包子资源状态

}

class ChiHuo extends Thread{

    private BaoZi bz;

    public ChiHuo(String name,BaoZi bz){

        super(name);

        this.bz = bz;

    }

    @Override

    public void run() {

        while(true){

            //把包子当做同步锁对象

            synchronized (bz){

                if(bz.flag == false){//没包子

                    try {

                        bz.wait();

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                }

                System.out.println("吃货正在吃包子");

                bz.flag = false;

                System.out.println("吃完了");

                bz.notify();

            }

        }

    }

}

class BaoZiPu extends Thread {

    private BaoZi bz;

    public BaoZiPu(String name,BaoZi bz){

        super(name);

        this.bz = bz;

    } @

            Override

    public void run() {

        int count = 0;

        while(true){

            synchronized (bz){

                if(bz.flag == true){//包子资源 存在

                    try {

                        bz.wait();

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                }

                System.out.println("包子铺开始做包子");

                count++;

                bz.flag=true;

                System.out.println("包子造好了");

                System.out.println("吃货来吃吧");

                //唤醒线程

                bz.notify();

            }

        }

    }

}

public class TestRunable {

    public static void main(String[] args){

        //创建包子对象

        BaoZi bz = new BaoZi();

        ChiHuo ch = new ChiHuo("吃货",bz);

        BaoZiPu bzp = new BaoZiPu("包子铺",bz);

        ch.start();

        bzp.start();

    }

}

5.线程池

线程池可以容纳多个线程，用于解决频繁创建线程和销毁线程的资源消耗，使线程可以被重复使用。

合理使用线程池的好处：

降低资源消耗。无需频繁创建线程和销毁。
提高响应速度。任务到达不需要等待线程创建就可以立即执行。
提高线程的可管理性。根据系统的承受能力，配置合适的线程数量。

Java里面线程池的顶级接口是 java.util.concurrent.Executor ，但是严格意义上讲 Executor 并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是 java.util.concurrent.ExecutorService 。

java.util.concurrent.Executors 线程工厂类里面提供了一些静态工厂，生成一些常用的线程池。（官方建议使用）

方法：

public static ExecutorService newFixedThreadPool(int nThreads) ：返回线程池对象。
public Future<?> submit(Runnable task) :获取线程池中的某一个线程对象，并执行。

使用步骤：

创建线程池对象。
创建Runable接口子类对象。
获得线程池对象，执行。
关闭线程池。（一般不做）

代码：

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

class MyRunnable implements Runnable {

    @Override

    public void run() {

        try {

            Thread.sleep(2000);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        System.out.println("调用了"+Thread.currentThread().getName());

    }

}

public class TestRunable {

    public static void main(String[] args){

        //创建线程池对象

        ExecutorService service = Executors.newFixedThreadPool(2);

        //创建 Runable 子类对象

        MyRunnable r = new MyRunnable();

        //获取线程对象 调用run

        for (int i =0;i<10;i++){

            service.submit(r);

        }

    }

}

温馨提示

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