Java笔记-多线程

创建多线程程序

Java程序属于抢占式调度
Thread类
创建多线程程序的两种方式
1.创建Thread类的子类，并在子类中重写run方法设置线程任务

package test.demo02;

import java.lang.Thread;

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

package test.demo02;

public class Thread00 {
    public static void main(String[] args) {
        MyThread mt= new MyThread();
        mt.start();
    }
}

Thread中的start()方法会另外新开辟一段栈空间，用于执行另一个进程中的方法，CPU随机选择执行哪一段栈空间的程序
2.实现Runnable接口：创建Runnable接口的实现类，在实现类中重写Runnable接口的run方法，再创建Thread类对象，构造方法中传递Runable接口的实现类对象

package test.demo02;

public class Runnablempl implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

package test.demo02;

import java.util.Arrays;

public class Demo01Method {
    public static void main(String[] args) {
    Runnablempl run =new Runnablempl();
    Thread t =new Thread(run);
    t.start();
    for (int i = 0; i < 20; i++) {
         System.out.println(Thread.currentThread().getName()+"-->"+i);

     }
  }
 }

运行结果：main和Thread-0轮流调用

Tread和Runnable方法的区别：
1.Java只支持单继承，一个类只能继承一个类，类继承了Thread就不能继承自其他类了；实现Runable接口还可以继承自其他类，实现其他的接口
2.Runnable增强了程序的扩展性，降低了耦合性，因为他把设置线程任务和开启新线程进行了分离(解耦)

线程安全问题

当几个进程同时访问一个资源，可能会造成线程安全问题，解决线程安全问题的方法有三个
1.同步代码块：在Runnable实现对象中使用synchronized及锁对象，所对象可以是任意一个对象，但是必须保证多个进程使用同一个锁对象

public class RunnableImpl implements Runnable{’
Object obj =new Object();
synchronized(obj){
	..... //可能出现安全问题的代码块
}
}

同步技术的原理：同步中的线程，没有执行完毕不会释放锁，同步外的线程没有锁进不去同步
2.同步方法：在Runnable实现对象RunnableImpl中使用synchronized关键字定义同步方法，同步方法的锁对象就是RunnableImpl对象

public sychronized void payTicket(){
	......//可能同步的代码块
}

3.Lock锁：
使用步骤
①在成员位置创建一个Reentrantlock对象
②在可能会出现安全问题的代码前使用lock方法
③在可能出现的问题后使用unlock方法

public class RunnableImpl implements Runnable{
Lock l =new Reentrantlock();
l.lock();
{
	..... //可能出现安全问题的代码块
}
l.unlock();
}

线程等待唤醒，线程间的通信

消费者生产者程序：
消费者告知生产者生产内容，然后等待生产者生产，生产证生产完之后通知消费者购买
obj.wait()和obj.notify()

package test.demo03;

public class wait_notify {
    public static void main(String[] args) {
        Object obj =new Object();
        //创建消费者线程
        new Thread(){
            @Override
            public void run() {
                while(true){
                    //保证等待和唤醒的进程只能有一个执行，需要使用同步技术
                    synchronized (obj){
                        //调用wait方法，放弃cpu执行，进入waiting状态
                        System.out.println("告知老板要的包子的种类和数量");
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("包子已经做好了，开吃");
                        System.out.println("---------------------------");
                    }
                }

            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                while(true){
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (obj){
                        System.out.println("老板5秒之后做包子，告知顾客，可以吃包子了");
                        //做好包子之后调用notify方法唤醒顾客吃包子
                        obj.notify();
                    }
                }
            }
        }.start();
    }
}

线程池

线程池是装载线程的LinkedList容器，当程序第一次启动的时候，创建多个线程保存到一个集合中，当我们想要使用线程的时候，就可以从集合中取出线程使用，JDK1.5之后提供线程池
线程池使用步骤：
1.使用线程池工厂类Executors里面提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
2.创建一个类，实现Runnable接口，重写run方法，设置线程任务
3.调用ExcutorService中的方法submit，传递线程任务(实现类),开启线程，E执行run方法

package test.demo03;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import static java.util.concurrent.Executors.newFixedThreadPool;

public class TreadPool {
    public static void main(String[] args) {
         ExecutorService es= Executors.newFixedThreadPool(2);
        es.submit(new RunnableImpl());
        es.submit(new RunnableImpl());
        es.submit(new RunnableImpl());
        es.submit(new RunnableImpl());
        es.submit(new RunnableImpl());
    }
}

package test.demo03;

import test.demo02.Runnablempl;

public class RunnableImpl implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"创建了一个新的线程");
    }
}