Java每日面试题7 (线程创建的4种方式，sleep和wait方法有什么区别)

最新推荐文章于 2023-05-28 20:34:29 发布

程序员小章

最新推荐文章于 2023-05-28 20:34:29 发布

阅读量306

点赞数

分类专栏：面试题文章标签：多线程 java 设计模式 thread 并发编程

原文链接：https://blog.csdn.net/weixin_41891854/article/details/81265772

版权

面试题专栏收录该内容

13 篇文章 2 订阅

订阅专栏

Java创建线程的四种方式

1.继承Thread类实现多线程

run()为线程类的核心方法，相当于主线程的main方法，是每个线程的入口
a.一个线程调用两次start()方法将会抛出线程状态异常，也就是的start()只可以被调用一次
b.native生明的方法只有方法名，没有方法体。是本地方法，不是抽象方法，而是调用c语言方法
registerNative()方法包含了所有与线程相关的操作系统方法
c. run()方法是由jvm创建完本地操作系统级线程后回调的方法，不可以手动调用（否则就是普通方法）

public class MyThread extends Thread {


	public void run() {
		for(int i=0;i<10;i++) {		System.out.println(Thread.currentThread()+":"+i);
		}
	}

	public static void main(String[] args) {
		MyThread mThread1=new MyThread();
		MyThread mThread2=new MyThread();
		MyThread myThread3=new MyThread();
		mThread1.start();
		mThread2.start();
		myThread3.start();
	}
}

2.覆写Runnable()接口实现多线程，而后同样覆写run().推荐此方式

a.覆写Runnable接口实现多线程可以避免单继承局限
b.当子类实现Runnable接口，此时子类和Thread的代理模式（子类负责真是业务的操作，thread负责资源调度与线程创建辅助真实业务。

public class MyThread implements Runnable{

	public static int count=20;
	
	public void run() {
		while(count>0) {
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}		System.out.println(Thread.currentThread().getName()+"-当前剩余票数:"+count--);
		}
	}


	public static void main(String[] args) {
		MyThread Thread1=new MyThread();
		Thread mThread1=new Thread(Thread1,"线程1");
		Thread mThread2=new Thread(Thread1,"线程2");
		Thread mThread3=new Thread(Thread1,"线程3");
		mThread1.start();
		mThread2.start();
		myThread3.start();
	}
}

继承Thread和实现Runnable接口的区别

a.实现Runnable接口避免多继承局限
b.实现Runnable()可以更好的体现共享的概念

3.覆写Callable接口实现多线程（JDK1.5）

a.核心方法叫call()方法，有返回值
b.有返回值

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


public class MyThread implements Callable<String> {
    private int count = 20;

    @Override
    public String call() throws Exception {

        for (int i = count; i > 0; i--) {
            Thread.yield();
            System.out.println(Thread.currentThread().getName()+"当前票数：" + i);
        }


        return "sale out";
    } 



    public static void main(String[] args) throws InterruptedException, ExecutionException {

        Callable<String> callable  =new MyThread();
        FutureTask <String>futureTask=new FutureTask<>(callable);

        Thread mThread=new Thread(futureTask);
        Thread mThread2=new Thread(futureTask);
        Thread mThread3=new Thread(futureTask);

        mThread.start();
        mThread2.start();
        mThread3.start();

        System.out.println(futureTask.get());
    }
}

4.通过线程池启动多线程

通过Executor 的工具类可以创建三种类型的普通线程池：

FixThreadPool(int n); 固定大小的线程池

使用于为了满足资源管理需求而需要限制当前线程数量的场合。使用于负载比较重的服务器。

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


public class Test {
	public static void main(String[] args) {
	
		ExecutorService ex=Executors.newFixedThreadPool(5);

		for(int i=0;i<5;i++) {
			ex.submit(new Runnable() {
				@Override
				public void run() {
					for(int j=0;j<10;j++) {				System.out.println(Thread.currentThread().getName()+j);
					}
				}
			});
		}
		ex.shutdown();
	}	
}

SingleThreadPoolExecutor :单线程池

需要保证顺序执行各个任务的场景

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

public class Test {
    public static void main(String[] args) {
        ExecutorService ex=Executors.newSingleThreadExecutor();

        for(int i=0;i<5;i++) {
            ex.submit(new Runnable() {
                @Override
                public void run() {
                    for(int j=0;j<10;j++) {			System.out.println(Thread.currentThread().getName()+j);
                                          }
                }
            });
        }
        ex.shutdown();
    }	
}

CashedThreadPool(); 缓存线程池

当提交任务速度高于线程池中任务处理速度时，缓存线程池会不断的创建线程
适用于提交短期的异步小程序，以及负载较轻的服务器

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

public class Test {
    public static void main(String[] args) {
        ExecutorService ex=Executors.newCachedThreadPool();

        for(int i=0;i<5;i++) {
            ex.submit(new Runnable() {

                @Override
                public void run() {
                    for(int j=0;j<10;j++) {
                        System.out.println(Thread.currentThread().getName()+j);

                    }
                }
            });
        }
        ex.shutdown();
    }	
}

线程之间的状态，及他们之间的相互转换

sleep() 和 wait() 的区别

结合synchronized，会更好的理解sleep()和wait()这两个方法，当然也就知道了他们的区别了。这篇博客就一起学习这两个方法

sleep()

sleep() 方法是线程类（Thread）的静态方法，让调用线程进入睡眠状态，让出执行机会给其他线程，等到休眠时间结束后，线程进入就绪状态和其他线程一起竞争cpu的执行时间。
因为sleep() 是static静态的方法，他不能改变对象的机锁，当一个synchronized块中调用了sleep() 方法，线程虽然进入休眠，但是对象的机锁没有被释放，其他线程依然无法访问这个对象。

下面用一个例子来演示：

Service类：

public class Service {

    public void mSleep(){
        synchronized(this){
            try{
                System.out.println(" Sleep 。当前时间："+System.currentTimeMillis());
                Thread.sleep(3*1000);
            }
            catch(Exception e){
                System.out.println(e);
            }
        }
    }

    public void mWait(){
        synchronized(this){
            System.out.println(" Wait 。结束时间："+System.currentTimeMillis());

        }
    }

}

就定义了两个方法， mSleep()方法会让调用线程休眠3秒，mWait() 就打印一句话。两个方法都使用了同步锁。

SleepThread类：

public class SleepThread implements Runnable{

    private Service service;

    public SleepThread(Service service){
        this.service = service;
    }

    public void run(){
        service.mSleep();
    }

}

线程类，用于调用Service 的mSleep方法

WaitThread类：

public class WaitThread implements Runnable{

    private Service service;

    public WaitThread(Service service){
        this.service = service;
    }

    public void run(){
        service.mWait();
    }

}

线程类，用于调用Service 的mWait方法

测试类：

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

        Service mService = new Service();

        Thread sleepThread = new Thread(new SleepThread(mService));
        Thread waitThread = new Thread(new WaitThread(mService));
        sleepThread.start();
        waitThread.start();

    }

}
1234567891011121314

创建了一个Service对象并赋值给mService，还创建了两个线程并传入mService，也就是说两个线程启动后，调用的是同一个Service对象的方法。
先看下结果：
这里写图片描述

梳理一下逻辑：

首先sleepThread线程会启动起来，然后在run方法里调用Service对象的mSleep方法，到了同步代码块后，this就是Test类里创建的Service对象mService，sleepThread线程获得了Service对象的锁，之后进入了休眠状态，但并没有释放该Service对象的锁。
这时waitThread线程也启动了起来，调用Service对象的mWait方法，同样到了同步代码块，因为Service对象的锁已经被sleepThread占了，所以waitThread线程只能干等着。
等到sleepThread线程执行完毕（休眠结束）后释放了同步锁，waitThread线程拿到了同步锁，会继续执行，mWait才会被调用。

如果sleepThread释放了机锁的话，waitThread 的任务会马上得到执行。从打印结果可以看出，waitThread 的任务是3秒钟之后才得到执行。

同步锁，锁住的是一个对象。如果一个线程拿到了一个对象的机锁去执行一段同步代码块了，那么其他线程都不能执行这个对象的其他同步代码块。
在这个例子中就是sleepThread线程拿到了service对象的同步锁，进入后休眠，但没有释放机锁，那么waitThread线程是不能执行这个service对象的其他同步代码块的，也就就是不能进入这一段代码

synchronized(this){
            System.out.println(" Wait 。结束时间："+System.currentTimeMillis());

}1234

相信现在你已经理解了sleep方法没有释放机锁会带来什么结果了，那么继续wait

wait()

wait()是Object类的方法，当一个线程执行到wait方法时，它就进入到一个和该对象相关的等待池，同时释放对象的机锁，使得其他线程能够访问，可以通过notify，notifyAll方法来唤醒等待的线程

下面修改程序如下所示：

public class Service {

    public void mSleep(){
        synchronized(this){

            try{
                Thread.sleep(3*1000);
                this.notifyAll();
                System.out.println(" 唤醒等待 。 结束时间："+System.currentTimeMillis());
            }
            catch(Exception e){
                System.out.println(e);
            }

        }

    }

    public void mWait(){

        synchronized(this){
            try{
                System.out.println(" 等待开始 。 当前时间："+System.currentTimeMillis());
                this.wait();
            }catch(Exception e){
                System.out.println(e);
            }
        }

    }

}

测试类：

public class Test{

    public static void main(String[] args){

        Service mService = new Service();

        Thread sleepThread = new Thread(new SleepThread(mService));
        Thread waitThread = new Thread(new WaitThread(mService));
        waitThread.start();
        sleepThread.start();

    }

}

同样先看下打印结果
这里写图片描述

这里是先让 waitThread线程启动起来，然后waitThread线程进入等待状态，并释放了Service对象的锁，这时sleepThread也启动了，来到了mSleep方法的同步代码块，因为之前的waitThread线程已经释放了Service对象的机锁，sleepThread可以拿到对象锁，所以mSleep方法是会被马上调用的。然后sleepThread线程就是进入了睡眠状态，等到3秒休眠结束后调用notifyAll()唤醒了waitThread线程。

综上所诉：
sleep() 和 wait() 的区别就是调用sleep方法的线程不会释放对象锁，而调用wait() 方法会释放对象锁

转载链接

程序员小章

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java每日面试题7 (线程创建的4种方式，sleep和wait方法有什么区别)

Java创建线程的四种方式1.继承Thread类实现多线程run()为线程类的核心方法，相当于主线程的main方法，是每个线程的入口a.一个线程调用两次start()方法将会抛出线程状态异常，也就是的start()只可以被调用一次b.native生明的方法只有方法名，没有方法体。是本地方法，不是抽象方法，而是调用c语言方法registerNative()方法包含了所有与线程相关的操作系统方法c. run()方法是由jvm创建完本地操作系统级线程后回调的方法，不可以手动调用（否则就是普通方法）
复制链接

扫一扫