一、Thread

Thread
线程的生命周期
解决线程安全问题
线程安全的单例模式之懒汉式
线程的同步——同步锁
线程的通信
消费者及生产者模型

Thread

Thread类的有关方法
- void start():启动线程，并执行对象的run()方法
- run():线程在被调度时执行的操作
- Staring getName():返回线程的名称
- void setName(String name):设置该线程名称
- static Thread currentThread():返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类
- yield():释放当前CPU的执行权
- join()：在线程a中调用线程b的join()，此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态
- stop():已过时，当执行此方法时，强制结束当前线程
- sleep(long millitime):让当前的线程休眠

创建线程

方式一：通过继承Thread

// 1.创建一个继承于thread类的子类
// 2.重写Thread类的run()
// 3.创建Thread类的子类的对象
// 4.通过此对象调用start()


class MyThread extends Thread{
    @Override
    public void run(){
        for(int i=0;i<100;i++){
            if(i%2==0){
                System.out.println(i);
            }
        }
  }
}
public class ThreadTest {
    public static void main(String args[]){
        MyThread t1 = new MyThread();

        t1.start();

        System.out.println("hello");
    }
}

方式二：通过重写Runnable接口的run方法

/*
* 创建多线程的方式二：实现Runnable接口
* 1.创建一个实现了Runnable接口的类
* 2.实现类去实现Runnable中的抽象方法:run()
* 3.创建实现类的对象
* 4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
* 5.通过Thread类的对象调用start()
* */

class MyThread implements Runnable{
    @Override
    public void run(){
        for(int i=0;i<100;i++){
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
public class ThreadMethodTest {
    public static void main(String args[]){
        MyThread mythread = new MyThread();
        Thread t1 = new Thread(mythread);
        t1.start();
    }
}

方式三：通过实现Callable接口


/*
1.call()方法可以有返回值
2.call()方法可以抛出异常，被外面的操作捕获，获取异常的信息
3.Callable是支持泛型的
*/

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


// 1.创建一个实现Callable的实现类
class NumThread implements Callable {
    // 2.实现call方法,将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception{
        int sum = 0;
        for(int i=0;i<100;i++){
            if(i%2 == 0){
                System.out.println(i);
            }
        }
        return sum;
    }

}

public class ThreadcallableTest {
    public static void main(String args[]){
        // 3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        // 4.将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);

        // 5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()方法
        new Thread(futureTask).start();

        try {
            // 6.获取Callable()中call方法的返回值
            // get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
            Object sum = futureTask.get();
            System.out.println(sum);
        }catch(InterruptedException e){
            e.printStackTrace();
        }catch(ExecutionException e){
            e.printStackTrace();
        }
    }
}

方式四：

/*
线程池
1.提高响应速度（减少了创建新线程的时间）
2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
3.便于线程管理
	corePoolSize:核心池的大小
	maximumPoolSzie:最大线程数
	keepAliveTime:线程没有任务时最多保持多长的时间后终止
*/

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


class NumberThread implements Runnable{
    @Override
    public void run(){
        for(int i=0;i<100;i++){
            if(i%2 == 0){
                System.out.println(i);
            }
        }
    }
}

public class ThreadPool {
    public static void main(String args[]){

        // 1.提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        
        // 设置线程池的属性
        // ThreadPoolExecutor service1 = (ThreadPoolExecutor) service; 
        //service1.setCorePoolSize();
        
        
        // 2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread()); // 适合使用于Runnable
        // service.submit(); // 适合使用于Callable

        service.shutdown();
    }
}

比较创建线程的两种方式

开发中：优先选择：实现RUnnable接口的方式
原因：1.实现的方式没有类的单继承性的局限性
	 2.实现的方式更适合来处理多个线程有共享数据的情况
	 
	 
联系：Thread实现了Runnable接口
相同点：两种方式都需要重写run()方法，将线程要执行的逻辑声明在run()中

线程的生命周期

解决线程安全问题

在java中，通过同步机制，来解决线程的安全问题

方法一：同步代码块

好处及坏处

好处：同步的方式，解决了线程的安全问题。
坏处：操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。

语法

synchronized(同步监视器){
    //需要被同步的代码
}
说明：（1）操作共享数据的代码，即为需要被同步的代码
     （2）共享数据：多个线程共同操作的变量
     （3）同步监视器：俗称：锁。任何一个类的对象，都可以充当锁
    		   要求：多个线程必须要共用同一把锁
      (4) 1)在实现Runnable接口创建多线程的方式中，可以考虑用this充当同步监视器
          2)在继承Thread类创建多线程的方式中，慎用This充当同步监视器，可以考虑使用当前类充当同步监视器（即CurrentClass.class）

示例1（重写runnable方法）

 
-- 示例
class MyThread implements Runnable{
    private int ticket = 100;
    Object obj = new Object(); // 一定要保证所有线程，共用同一把锁

    @Override
    public void run(){
        while(true){
            synchronized(obj){ //obj可以用this替代，用不着重新创建一个对象
                if(ticket>0){
                    try{
                        Thread.sleep(100);
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+ticket);
                    ticket--;
                }
                else{
                    break;
                }
            }
        }
    }
}


public class ThreadMethodTest {
    public static void main(String args[]){
        MyThread mythread = new MyThread(); -- 共用同一个对象
        Thread t1 = new Thread(mythread);
        Thread t2 = new Thread(mythread);
        Thread t3 = new Thread(mythread);
        t1.start();
        t2.start();
        t3.start();
    }
}

示例2（继承Thread）

class MyThread extends Thread{
    private int ticket = 100;
    private static Object obj = new Object(); // 一定要保证所有线程，共用同一把锁

    @Override
    public void run(){
        while(true){
            synchronized(obj){  //obj可以用MyThread.class来替代，该对象唯一，MyThrea只会加载一次
                if(ticket>0){
                    try{
                        Thread.sleep(100);
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+ticket);
                    ticket--;
                }
                else{
                    break;
                }
            }
        }
    }
}
public class ThreadTest {
    public static void main(String args[]){
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

        t1.start();
        t2.start();
        t3.start();
        
        System.out.println("hello");
    }
}

方法二：方法声明为synchronized类型

说明

关于同步方法的总结：
1.同步方法仍然涉及到同步监视器，只是不需要显示的声明
2.（1）非静态的同步方法，同步监视器是：this
  （2）静态的同步方法，同步监视器是：当前类本身(即CurrentClass.class)

示例1

class MyThread implements Runnable{
    private int ticket = 100;
    // Object obj = new Object(); // 一定要保证所有线程，共用同一把锁

    @Override
    public void run(){
        while(true){
      		this.show();
      	}
    }
    
    public synchronized void show(){
           // synchronized(obj){ //obj可以用this替代，用不着重新创建一个对象
                if(ticket>0){
                    try{
                        Thread.sleep(100);
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+ticket);
                    ticket--;
                }
                else{
                    break;
                }
            //}
   }
}


public class ThreadMethodTest {
    public static void main(String args[]){
        MyThread mythread = new MyThread(); -- 共用同一个对象
        Thread t1 = new Thread(mythread);
        Thread t2 = new Thread(mythread);
        Thread t3 = new Thread(mythread);
        t1.start();
        t2.start();
        t3.start();
    }
}

示例二

class MyThread extends Thread{
    private int ticket = 100;
   // private static Object obj = new Object(); // 一定要保证所有线程，共用同一把锁

    @Override
    public void run(){
        while(true){
            //synchronized(obj){  //obj可以用MyThread.class来替代，该对象唯一，MyThrea只会加载一次
                this.show();
            //}
        }
		
    }
    public  static  synchronized void show(){ //使用了Mythread.class来保证监视器的唯一
         
               if(ticket>0){
                    try{
                        Thread.sleep(100);
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+ticket);
                    ticket--;
                }
                else{
                    break;
                }
    }
}
public class ThreadTest {
    public static void main(String args[]){
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

        t1.start();
        t2.start();
        t3.start();
        
        System.out.println("hello");
    }
}

线程安全的单例模式之懒汉式

示例

public class DemoTest{
    
}


// 方式一：效率比较差，每个线程都需要在初始化时进行一次判断，进行抢锁
class Demo{
    private Demo(){
        
    }
    
    private static Demo instance = null;
    
    public static synchronized Demo getInstance(){
        if(instance==null){
            instance = Demo Bank();
        }
        return instance;
    }
}

//方式二：效率稍高,每次初始化调用时，都会进行判断，如果已经不是null值，就不进行抢锁的行为，而是直接返回其值，否则，再去抢锁初始化instance
class Demo{
    
    private Demo(){}
    
    private static Demo instance = null;
    
    public static Demo getInstance(){
        if(instance==null){
            synchronized(Demo.class){
                if(instance==null){
                    instance = new Demo();
                }
            }
        }
        return instance;
    }
    
}

线程的同步——同步锁

说明

Synchronized与lock的异同？
- 相同点：二者都可以解决线程安全问题
- 不同点：（1）Synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
         （2）Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）

示例

import java.util.concurrent.locks.ReentrantLock;

class Demo implements Runnable{

    private int ticket = 100;

    // 1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run(){
        while(True){
            try{
                lock.lock(); // 2.调用锁定的方法lock()

                if(ticket>0){
                    try{
                        Thread.sleep(100);
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":"+ticket);
                    ticket--;
                }else{
                    break;  // 3.调用解锁方法:unlock()
                }
            }finally{
                lock.unlock();
            }
        }
    }
}

public class LockTest {
    public static void main(String args[]){
        Demo mydemo= new Demo(); -- 共用同一个对象
        Thread t1 = new Thread(mydemo);
        Thread t2 = new Thread(mydemo);
        Thread t3 = new Thread(mydemo);
        t1.start();
        t2.start();
        t3.start();
    }
}

线程的通信

说明

涉及到的三个方法：
wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器
notify():一旦执行此方法，就会唤醒被wait的一个线程，如果有多个线程被wait,就唤醒优先级最高的
notifyall():一旦执行此方法，就会唤醒所有被wait的线程

注意点：
（1）wait()、notify()、notifyALL()三个方法必须使用在同步代码块或同步方法中。
（2）wait()、notify()、notifyALL()三个方法的调用者必须是同步代码块或同步方法中的监视器（比如this或CurrentClass.class）
（3）wait()、notify()、notifyALL()三个方法是定义在java.lang.Object类中。


sleep()和wait()的异同？
- 相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态
- 不同点：（1）两个方法声明的位置不同：Thread类中声明sleep(),Object类中声明wait()
         （2）调用的要求不同：sleep()可以在任何需要的场景下调用，wait()必须在同步代码块或同步方法中
         （3）关于是否释放同步监视器：如果两个方法都使用在同步代码快或同步方法中，sleep()不会释放锁，wait()会释放锁

消费者及生产者模型

说明

示例

/*
* 线程通行的应用
* 经典例题：生产者/消费者模型
*
* 分析
* 1.是否是多线程问题：是
* 2.是否有共享数据：是
* 3.如何解决线程的安全问题：同步机制，有三种方法
* 4.是否涉及线程的通信：是
*
* */


class Clerk{

    // 1.申明一个元素，表示产品
    private int productCount = 0;

    public synchronized void productProduct(){  // 2.变成同步方法
        if(productCount<20){
            productCount++;
            System.out.println(Thread.currentThread().getName()+":开始生产第"+productCount+"个产品");
            notify();  // 4.释放锁，避免死锁
        }else{
            try{
                wait();  // 3.等待线程完成
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        }
    }

    public synchronized void consumeProduct(){
        if(productCount>0){
            System.out.println(Thread.currentThread().getName()+":开始消费第"+productCount+"个产品");
            productCount--;
            notify();
        }else{
            try{
                wait();
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

class Producer extends Thread{

    private Clerk clerk;
    //1.创建一个构造器
    public Producer(Clerk clerk){
        this.clerk = clerk;
    }
    //2.重写run方法
    @Override
    public void run(){
        System.out.println(Thread.currentThread().getName()+":开始生产产品...");
        while(true){
            try{
                //3.睡眠100毫秒
                Thread.sleep(100);
            }catch(InterruptedException e){
                e.printStackTrace();
            }
            // 4.调用对象的生产方法
            clerk.productProduct();
        }
    }
}

class Customer extends Thread{
    private Clerk clerk;

    public Customer(Clerk clerk){
        this.clerk = clerk;
    }

    @Override
    public void run(){
        System.out.println(Thread.currentThread().getName()+":开始消费产品...");
        while(true){
            try{
                Thread.sleep(1000);
            }catch(InterruptedException e){
                e.printStackTrace();
            }

            clerk.consumeProduct();
        }
    }
}



public class ProductTest {
    public static void main(String args[]){
        // 1.声明一个clerk对象
        Clerk clerk = new Clerk();

        // 2.声明一个生产者
        Producer p1 = new Producer(clerk);
        // 3.设置线程名称
        p1.setName("生产者1号");

        // 4.声明一个消费者
        Customer c1 = new Customer(clerk);
        // 5.设置线程名称
        c1.setName("消费者1号");

        // 6.启动线程
        p1.start();
        c1.start();

    }
}

posted @ 2021-05-12 23:52 Norni 阅读(137) 评论(0) 编辑收藏举报

刷新页面返回顶部