java-多线程

进程:是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间,一个应用程序可以同时运行多个进程;进程也是程序的一次执行过程,是系统运行程序的基本单位;系统运行一个程序即是一个进程从创建、运行到消亡的过程。

线程:线程是进程中的一一个执行单元,负责当前进程中程序的执行,一个进程中至少有一个线程。一个进程中是可以有多个线程的,这个应用程序也可以称之为多线程程序。

简而言之: 一个程序运行后至少有一个进程,一个进程中可以包含多个线程

创建线程第一种方式

创建多线程程序的第一种方式:创建Thread类的子类

java. lang.Thread类:是描述线程的类,我们想要实现多线程程序,就必须继承Thread类

实现步骤:

1.创建一个Thread类的子类

2.在Thread类的子类中重写Thread类中的run方法,设置线程任务(开启线程要做什么?)

3.创建Thread类的子类对象

4.调用Thread类中的方法start方法,开启新的线程,执行run方法

void start() 使该线程开始执行; Java虚拟机调用该线程的run方法。结果是两个线程并发地运行;当前线程(main线程)和另一个线程(创建的新线程,执行其run方法)。多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。

public class MyThread extends Thread {
    @Override
    public void run() {
        for(int i = 0 ; i < 10;i++){
            System.out.print(i);
        }

    }
}
....
public static void main(String[] args) {
        //创建线程对象
        MyThread thread = new MyThread();
        //开启线程
        thread.start();
}    

多线程流程  

多线程内存图

Thread中常用方法

//1.使用Thread类中的方法getName()
	String getName();// 返回该线程的名称。
//2.可以先获取到当前正在执行的线程,使用线程中的方法getName( )获取线程的名称
	static Thread currentThread();// 返回对当前正在执行的线程对象的引用。
//3.使用Thread类中的方法setName(名字)
	void setName(String name);// 改变线程名称，使之与参数name 相同。
//4.创建一个带参数的构造方法, 参数传递线程的名称;调用父类的带参构造方法，把线程名称传递给父类,让父类( Thread)给子线程起一个名字
	Thread(String name);//分配新的Thread 对象。
//5.使当前正在执行的线程以指定的毫秒数暂停(暂时停止执行)。
public static void sleep(long millis);//毫秒数结束之后,线程继续执行


//定义一个Thread类的子类
public class MyThread extends Thread{
    //重写Thread类中的run方法,设置线程任务
    @Override
    public void run() {
        //获取线程名称
        String name = getName();
        System.out.println(name);
        Thread t = Thread.currentThread();
        System.out.println(t);//Thread[ Thread-0, 5, main]
        String name = t.getName();
        System.out.printin(name);
        System.out.println(Thread.currentThread().getName());
    }
}

线程创建第二种方式

实现Runnable接口

java.lang.Runnable

Runnable接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个个称为run 的无参数方法。

java. lang. Thread类的构造方法

Thread(Runnable target) 分配新的Thread 对象。

Thread(Runnable target, String name) 分配新的Thread 对象。

实现步骤:

1.创建一个Runnable接口的实现类

2.在实现类中重写Runnable接口的run方法,设置线程任务

3.创建一个Runnable接口的实现类对象

4.创建Thread类对象,构造方法中传递Runnable接口的实现类对象

5.调用Thread类中的start方法,开启新的线程执行run方法

public class RunnableImpl implements Runnable {
    @Override
    public void run() {
        //....执行代码
    }
}
......
public static void main(String[] args) {
    //3.创建- -个Runnabl e接口的实现类对象
    RunnableImpl run = new RunnableImpl();
    //4.创建Thread类对象,构造方法中传递Runnable接口的实现类对象
    Thread t = new Thread(run);
    //5.调用Thread类中的start方法,开启新的线程执行run方法
    t.start();
}

实现Runnable接口创建多线程程序的好处:

1.避免了单继承的局限性

一个类只能继承一个类每个类只能有一个亲爹,类继承了Thread类就不能继承其他的类，但实现了 Runnable接口，还可以继承其他的类和实现其他的接口

2.增强了程序的扩展性,降低了程序的耦合性(解耦)

实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离(解耦)实现类中,重写了run方法:用来设置线程任务创建Thread类对象,调用start方法:用来开启新线程

匿名内部类实现线程创建

匿名内部类作用:简化代码

把子类继承父类，重写父类的方法，创建子类对象合一步完成

把实现类实现类接口，重写接口中的方法，创建实现类对象合成一步完成

public static void main(String[] args) {
    //线程的父类是Thread
    // new MyThread(). start();
    new Thread(){
        //重写run方法,设置线程任务
        @Override
        public void run() {
            for(int i = 0; i < 20 ; 1++){
                System.out.println(Thread.currentThread().getName()+"-->"+"黑马");
            }
           }
        }.start();
	//线程的接口Runnable
    //Runnable run = new RunnableImpl();//多态
    Runnable r =new Runnable(){
            //重写run方法,设置线程任务
            @Override
            public void run(){
                for(inti=0;i<20;i++){
                    System.out.print1n( Thread.currentThread().getName()+"-->"+“程序员");
                }
        }
    new Thread(r).start();  
    //简化版本
    new Thread(new Runnable(){
        @Override
        public void run(){
            //执行的代码
        }
    }).start();                               
                                   
}

线程安全

线程同步-synchronized

//解决线程安全问题的一种方案:使用同步代码块
//格式:
synchronized(锁对象){
	//可能会出现线程安全问题的代码(访问了共享数据的代码)
}

注意:

1.通过代码块中的锁对象,可以使用任意的对象

2.但是必须保证多个线程使用的锁对象是同一个

3.锁对象作用:把同步代码块锁住,只让一个线程在同步代码块中执行

public class RunnableImpl implements Runnable{
    //定义一个多个线程共享的票源
    private int ticket = 100;
    //创建一个锁对象
    object obj = new object();
    //设置线程任务:卖票
    @Overrider
    public void run() {
    //使用死循环，让卖票操作重复执行
    while(true){
        //同步代码块
        synchronized (obj){
            //先判断票是否存在
            if(ticket>0){
                //提高安全问题出现的概率，让程序睡眠
                try {
                    Thread.sleep( millis: 10);
                } catch (InterruptedException e) {
                    e.printstackTrace();
                }
                //票存在,卖票. ticket--
                System.out.println(Thread.currentThread().getName()+"-- >正在卖第"+ticket+ "张票");
                ticket--;
            }
       	}
     }
   }
}

同步技术原理

同步方法解决线程安全

解决线程安全问题的二种方案:使用同步方法

使用步骤:

1.把访问了共享数据的代码抽取出来,放到一个方法中

2.在方法上添加synchronized修饰符

 

//设置线程任务:卖票
@Override
public void run() {
    //使用死循环,让卖票操作重复执行
    while(true){
    	payTicket();
    }
}
//定义一个同步方法
public synchronized void payTicket(){
    //先判断票是否存在
    if(ticket > 0){
    //提高安全问题出现的概率,让程序睡眠
    try {
    	Thread.sleep(10);
    catch (InterruptedException e) {
        e. printStackTrace();
    }
    //票存在，卖票ticket--
    System.out.println(Thread. current Thread().getName()+"-- >正在卖第"+ticket+"张票"); .
    ticket--;
}

lock锁

解决线程安全问题的三种方案:使用Lock锁

java.util.concurrent.locks.Lock接口

Lock.实现提供了比使用synchronized 方法和语句可获得的更广泛的锁定操作。

Lock接口中的方法:

void lock( )获取锁。

void unlock()释放锁。

java.util.concurrent.locks.ReentrantLock implements Lock接口

使用步骤:

1.在成员位置创建一个Reentrantlock对象

2.在可能会出现安全问题的代码前调用Lock接口中的方法Lock获取锁

3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁

 

//创建锁对象
ReentrantLock l = new ReentrantLock();
//设置线程任务:卖票
@Override
public void run() {
    //使用死循环，让卖票操作重复执行
    while(true){
        //2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
        l.lock();
        //先判断票是否存在
        if(ticket>0){.
            //提高安全问题出现的概率,让程序睡眠
            try {
                Thread.sleep(10);
                //票存在,卖票ticket--
                System.out.println(currentThread().getName()+"-- >正在卖第"+ticket+"张票");
                ticket--;
            } catch (InterruptedException e) {
                e. printStackTrace();
            }finally {
                //3.在可能会出现安全问题的代码后调用lock接口中的方法unlock释放锁
                l.unlock();//无论程序是否异常，都会把锁释放
            }
     }
}

线程状态

等待与唤醒机制

为什么要处理线程间通信:

多个线程并发执行时,在默认情况下CPU是随机切换线程的,当我们需要多个线程来共同完成一件任务,并且我们希望他们有规律的执行,那么多线程之间需要一些协调通信 ,以此来帮我们达到多线程共同操作一份数据。

如何保证线程间通信有效利用资源: 多个线程在处理同一个资源,并且任务不同时,需要线程通信来帮助解决线程之间对同一个变量的使用或操作。就是多个线程在操作同一份数据时，避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段即一一等待唤醒机制。

调用wait和notify方法需要注意的细节

1. wait方法与notify方法必须要由同一个锁对象调用。因为:对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。

2. wait方法与notify方法是属于Object类的方法的。因为:锁对象可以是任意对象,而任意对象的所属类都是继承了object类的。

3. wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为:必须要通过锁对象调用这2个方法。

 

等待唤醒案列

package 进程与线程;

/**
 * 等待唤醒案例:线程之间的通信 
 *创建一个顾客线程(消费者):告知老板要的包子的种类和数量，调用wait方法,放弃cpu的执行,进入到WAITING状态(无限等待)
 * 创建一个老板线程(生产者):花了5秒做包子，做好包子之后，调用notify方法,唤醒顾客吃包子
 *
 *注意:
 * 顾客和老板线程必须使用同步代码块包裹起来,保证等待和唤醒只能有一个在执行
 * 同步使用的锁对象必须保证唯一只有锁对象才能调用wait和notify方法
 *
 *obejct类中的方法
 * void wait()
 * 在其他线程调用此对象的notify() 方法或notifyAll() 方法前，导致当前线程等待。
 * void notify()
 * 唤醒在此对象监视器上等待的单个线程。
 * 会继续执行wait方法之后的代码
 * */
public class WaitAndNotify {
    public static void main(String[] args) {
        //创建锁对象，保证唯一
        Object obj = new Object();
        //创建一个顾客线程（消费者）
        new Thread(){
            @Override
            public void run() {
                //保证等待和唤醒的线程只能有一个执行,需要使用同步技术
                synchronized (obj) {
                    System.out.println("告知老板要的包子的种类和数量");
                    //调用wait方法,放弃cpu的执行,进入到WAITING状态(无限等待)
                    try {
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //唤醒之后的代码
                    System.out.println("包子已经做好，开吃");

                }
            }
        }.start();

        //创建一个老板线程(生产者)
        new Thread(){
            @Override
            public void run() {
                //花5秒钟做包子
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //保证等待和唤醒的线程只能有一个执行,需要使用同步技术
                synchronized (obj) {
                    System.out.println("老板5秒钟之后做好包子，告知顾客吃包子");
                    //调用wait方法,放弃cpu的执行,进入到WAITING状态(无限等待)
                    obj.notify();
                }
            }
        }.start();
    }
}

wait带参数和notifyAll方法

进入到TimeWaiting(计时等待)有两种方式

1.使用sleep(long m)方法, 在毫秒值结束之后,线程睡醒进入到Runnable/Blocked状态

2.使用wait(long m)方法， wait方法如果在毫秒值结束之后，还没有被notify唤醒,就会自动醒来,线程睡醒进入到Runnable/Blocked状态

notifyAll：唤醒所有等待的线程

线程池

线程的创建和销毁需要浪费大量时间，线程池可以使使用过的线程再次被使用

线程池:其实就是一个容纳多个线程的容器,其中的线程可以反复使用,省去了频繁创建线程对象的操作,无需反复创建线程而消耗过多资源。

public static void main(String[] args). {
    //1. 使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
    ExecutorService es = Executors.newFixedThreadPool(2);
    //3.调用Executorservice中的方法submit,传递线程任务(实现类),开启线程,执行run方法
    es.submit(new RunnableImpl());
}