A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

1.多线程的实现有几种方式?实现步骤分别是怎样的?
2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
4.sleep()方法和wait()方法的区别?

71 个回复

倒序浏览
1.多线程的实现有几种方式?实现步骤分别是怎样的?
答:两种分别是继承Thread类来创建和定义Runnable接口的实现类;
Thread类:1. 定义Thread类的子类,并重写该类的run()方法,该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。2. 创建Thread子类的实例,即创建了线程对象3. 调用线程对象的start()方法来启动该线程
Runnable接口:1. 定义Runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。2. 创建Runnable实现类的实例,并以此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象。3. 调用线程对象的start()方法来启动线程

2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
答:
1. 适合多个相同的程序代码的线程去共享同一个资源。
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性,实现解耦操作,代码可以被多个线程共享,代码和线程独立。
4. 线程池只能放入实现Runable或Callable类线程,不能直接放入继承Thread的类

3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
答:线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作,而无写操作,一般来说,这个全局变量是线程安全的;若有多个线程同时执行写操作,一般都需要考虑线程同步,否则的话就可能影响线程安全
三种方式解决:同步代码块,synchronized 关键字可以用于方法中的某个区块中,表示只对这个区块的资源实行互斥访问;同步方法,使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着;Lock锁,lock()加同步锁unlock() :释放同步锁

4.sleep()方法和wait()方法的区别?
答:sleep()方法导致了程序暂停执行指定的时间,让出cpu该其他线程,但是他的监控状态依然保持者,当指定的时间到了又会自动恢复运行状态。在调用sleep()方法的过程中,线程不会释放对象锁。而当调用wait()方法的时候,线程会放弃对象锁,进入等待此对象的等待锁定池,只有针对此对象调用notify()方法后本线程才进入对象锁定池准备
回复 使用道具 举报
1.多线程的实现有几种方式?实现步骤分别是怎样的?
答:
有两种实现方式,一种是继承Thread类,一种是实现Runnable接口。
(1).继承Thread类
定义Thread类的子类,并重写该类的run()方法,该run()方法的方法体就代表了线程需要完成的任务,因此把 run()方法称为线程执行体。
创建Thread子类的实例,即创建了线程对象
调用线程对象的start()方法来启动该线程

(2).实现Runnable接口:
定义Runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。
创建Runnable实现类的实例,并以此实例作为Thread的target来创建Thread对象,该Thread对象才是真正 的线程对象。
调用线程对象的start()方法来启动线程。

2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
答:
区别在于,继承Thread类不适合进行资源共享,而实现Runnable接口则更适合实现资源共享。
优势在于:
1. 适合多个相同的程序代码的线程去共享同一个资源。
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性,实现解耦操作,代码可以被多个线程共享,代码和线程独立。 4. 线程池只能放入实现Runable或Callable类线程,不能直接放入继承Thread的类。

3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
答:
线程安全问题是由全局变量及静态变量引起的,如果多个线程对全局变量及静态变量进行写操作,就会发生线程安全问题。
解决线程安全问题有以下方法:
1. 同步代码块。
2. 同步方法。
3. 锁机制。
4.sleep()方法和wait()方法的区别?
答:
1.wait方法是来源于Object类的方法,sleep是来源与Thread方法


2.wait方法调用后,会释放锁对象和CPU执行权,sleep方法调用后,只会释放CPU执行权,不会释放锁对象
回复 使用道具 举报
1.多线程的实现有几种方式?实现步骤分别是怎样的?
多线程的实现由三种方式
1.继承Thread
步骤:1.创建一个子类继承Thread类
      2.在这个子类重写run方法
      3.在main函数里创建子类对象
      4.通过start方法开启新线程,运行run方法
2.实现Runnable接口
步骤:1.创建一个Runnable接口的实现类
      2.在该实现类重写run方法
      3.在main函数里创建实现类对象
      4.创建Thread对象调用start方法开启新线程,运行run方法
3.匿名内部类
步骤:1.在main函数里新建一个Thread或者Runnable
      2.重写这个匿名内部类的run方法
      3.通过start方法开启新线程,运行run方法

2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
使用继承Thread类的方式重写的run方法无法被重复利用,耦合度太高(既具有创建对象的功能,又有线程任务的功能),且该方式会占用一个继承位;实现Runnable接口的方式只具有线程任务的功能,耦合度低,且重写的run方法能重复使用,可以继承其他类或者多个接口。

3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
如果有多个线程同时操作同一个资源,并对这个资源中的数据进行修改时,会产生线程安全问题。
解决线程安全问题的方式:
1.同步代码块
使用格式:synchronized(同步锁){进行同步操作的代码}
2.同步方法
在Runnable实现类里定义一个使用synchronized修饰的方法
使用格式:修饰符 synchronized 返回值类型 方法名(参数列表){进行同步操作的代码}
3.Lock锁
在Runnable实现类里新建一个ReentrantLock()对象,调用lock和unlock方法加同步锁和释放同步锁
使用格式执行同步操作代码前加同步锁方法,结束后执行释放同步锁方法

4.sleep()方法和wait()方法的区别?
区别:
1.来源:sleep是object类的方法
        wait是thread类的方法
2.释放对象:sleep方法使用后只能释放cpu执行权
            wait方法同时释放锁对象和cpu执行权

点评

多线程的实现方式是两种,你想想,你这边写得第三种是代码的实现方式是不是?  发表于 2019-3-28 09:25
回复 使用道具 举报
李伟斌

1.多线程的实现有几种方式?实现步骤分别是怎样的?
答:继承Thread和实现Runnable接口两种。
   Thread的实现步骤:a.继承Thread类  b.重写run方法  c.创建子类对象  d.子类对象.start方法
   Runnable接口的实现步骤:a.实现Runnable接口  b.重写run方法  c.创建子类对象 d.创建Thread对象,new Thread(子类对象)  e.使用start方法开启线程
2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
答:实现Runnable接口比继承Thread类所具有的优势:
    a.适合多个相同的程序代码的线程去共享同一个资源。
    b.可以避免java中的单继承的局限性。
    c.增加程序的健壮性,实现解耦操作,代码可以被多个线程共享,代码和线程独立。
    d.线程池只能放入实现Runable或Callable类线程,不能直接放入继承Thread的类
3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
答:多个线程在抢CPU时,抢到CPU的线程代码还没执行完,CPU又跑去执行另外一条线程,造成数据重复以及不存在的数据产生。
    当线程抢到资源要执行时,需要用锁锁住,让线程执行完再释放锁。
    有同步代码块,同步方法,和lock锁三种方式解决。
4.sleep()方法和wait()方法的区别?
答:sleep()方法属于Thread类,会自动唤醒自己,代码执行完时不释放锁。
    wait()方法属于Object类,需要notify方法进行唤醒,代码执行完后会释放锁。
回复 使用道具 举报
1.多线程的实现有几种方式?实现步骤分别是怎样的?
有2种;
a.使用子类继承Thread类,重写run方法,创建子类对象,使用子类对象名调用start方法
b.实现Runnable接口,重写run方法,创建Thread类对象,参数为Runnable的实现类对象或匿名内部类,通过Thread类对象调用start方法

2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
Thread类只能继承,需要占用子类的继承位,且子类的功能和多线程混在一起,代码耦合度较高;
实现Runnable接口比继承Thread类所具有的优势:


1. 适合多个相同的程序代码的线程去共享同一个资源。

2. 可以避免java中的单继承的局限性。

3. 增加程序的健壮性,实现解耦操作(将设置线程的任务和开启新线程分离),代码可以被多个线程共享,代码和线程独立。

4. 线程池只能放入实现Runable或Callable类线程,不能直接放入继承Thread的类。




3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
当多个线程都对共享的资源进行修改操作时,可能出现线程安全问题;
解决方式:
1.同步代码块
synchronized(同步锁){
    可能产生线程安全问题的代码
}
2.同步方法
public synchronized void 方法名(){可能产生线程安全问题的代码}

3.Lock锁
在成员变量位置定义
Lock lock = new ReentrantLock;

lock.lock();


可能产生线程安全问题的代码


lock.unlock();


4.sleep()方法和wait()方法的区别?
1.sleep方法是Thread类中的方法,wait是Object类中的方法
2.sleep方法等待时只释放cpu,wait方法会同时释放cpu和锁
回复 使用道具 举报
1.多线程的实现有几种方式?实现步骤分别是怎样的?
两种方式 创建继承Thread的子类      new Thread(借口Runnable的实现类)
2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
避免了单继承的局限性
增强了程序的扩展性,降低了程序的耦合性
3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
4.sleep()方法和wait()方法的区别?
sleep并没有释放锁对象

点评

第3点呢?  发表于 2019-3-28 09:32
回复 使用道具 举报
1.多线程的实现有几种方式?实现步骤分别是怎样的?
第一种:继承Thread
步骤如下:
    1. 定义Thread类的子类,并重写该类的run()方法,该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
    2. 创建Thread子类的实例,即创建了线程对象
    3. 调用线程对象的start()方法来启动该线程
第二种:实现Runnable接口
步骤如下:
   1. 定义Runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。
   2. 创建Runnable实现类的实例,并以此实例作为Thread的target来创建Thread对象,该Thread对象才是真正
的线程对象。
   3. 调用线程对象的start()方法来启动线程

2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
    如果一个类继承Thread,则不适合资源共享。但是如果实现了Runable接口的话,则很容易的实现资源共享。

实现Runnable接口比继承Thread类所具有的优势:
   1. 适合多个相同的程序代码的线程去共享同一个资源。
   2. 可以避免java中的单继承的局限性。
   3. 增加程序的健壮性,实现解耦操作,代码可以被多个线程共享,代码和线程独立。
   4. 线程池只能放入实现Runable或Callable类线程,不能直接放入继承Thread的类

3.线程安全问题是怎么产生的?如何解决线程安全问题,有哪几种方式?
    当我们使用多个线程访问同一资源的时候,且多个线程中对资源有写的操作,就容易出现线程安全问题
解决方式:
    1,同步代码块: synchronized 关键字可以用于方法中的某个区块中,表示只对这个区块的资源实行互斥访问。
    2,同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着
    3,Lock锁:java.util.concurrent.locks.Lock 机制提供了比synchronized代码块synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。
4.sleep()方法和wait()方法的区别?
在指定的毫秒数内让当前正在执行的线程休眠(暂停执行),此操作受到系统计时器和调度程序精度和准确性的影响。该线程不丢失任何监视器的所属权。

在其他线程调用此对象的 notify() 方法或 notifyAll() 方法,或者其他某个线程中断当前线程,或者已超过某个实际时间量前,导致当前线程等待
回复 使用道具 举报
本帖最后由 陈伟彬 于 2019-3-30 21:45 编辑

1.多线程的实现有几种方式?实现步骤分别是怎样的?
答:
        三种;
        继承Thread类:
                创建一个继承Thread类的子类;
                在子类里重写Thread类里面的run方法,设置线程任务;
                在测试类里创建这个子类的对象;
                调用start方法开启新线程,运行重写后的run方法;
        实现Runnable接口:
                创建一个Runnable接口的实现类;
                在这个实现类里重写run方法,设置线程任务;
                在测试类里创建这个实现类的对象;
                创建Thread类对象来调用start方法开启新线程,运行重写的run方法;
        匿名:
                直接在测试类new一个Thread类或Runnable接口
                然后重写里面的run方法,设置线程任务;
                调用start方法开启新线程,运行重写后的run方法;
                如果是直接new Runnable接口,还需要创建一个Thread类对象来调用start方法;
2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
答:
        区别与优势:
                耦合度:
                        继承Thread类的既具有创建对象的功能,又有线程任务的功能,耦合度高;
                        实现Runnable接口的只有线程任务的功能,耦合度低;
                局限性:
                        继承Thread类的只能有一个子类,直接创建子类会占用继承位,局限性高;
                        实现Runnable接口的可以可以有多个实现类,不会占位,局限性低;
                资源共享:
                        继承Thread类的资源和线程对象是合在一起的,无法共享同一资源;
                        实现Runnable接口的资源和线程对象分离,则实现了资源共享;
3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
答:
        线程安全问题:多个 线程操作同一个资源,在对资源的数据执行修改操作的时候,此时有可能会发生线程安全问题;
        解决方案:进行线程同步,让可能会出现问题的代码,只能有一个线程在里面运行;
        方式:;
                同步代码块:synchronize(锁对象){可能出现线程安全问题的代码};
                同步方法:public synchronize 返回值类型 方法名(){可能出现线程安全问题的代码};
                        静态同步方法:public start synchronize 返回值类型 方法名(){可能出现线程安全问题的代码};
                Lock锁:先创建一个Reentrantlock对象;然后在问题代码前获取锁(void lock());最后在问题代码后释放锁(void unlock());
4.sleep()方法和wait()方法的区别?
答:
        区别:
                来源:
                        sleep方法是来源于Thead类的方法;
                        wait方法是来源于Object类的方法;
                释放对象:
                        sleep方法调用后,只会释放CPU执行权,不会释放锁对象;
                        wait方法调用后,会释放锁对象和CPU执行权;

点评

sleep()和wait()各自属于哪个对象?  发表于 2019-3-28 10:24
回复 使用道具 举报
1.多线程的实现有几种方式?实现步骤分别是怎样的?

多线程的实现有两种方式。
第一种步骤:
①定义Thread类的子类,并重写该类的run()方法,该run()方法的方法体就是该线程的执行体。
②创建Thread子类的实例,就是创建线程对象
③调用线程对象的start()方法来开启线程

第二种步骤:
①定义Runnable接口的实现类,并重写该接口的run()方法。该run()方法就是该线程的执行体。
②创建Runnable接口的实现类实例,并以此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象
③调用线程对象的start()方法来开启线程

2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?

继承Thread类和实现Runnable接口的区别是:
继承Thread类:不适合资源的共享
实现Runnable接口:很容易实现资源共享

实现Runnable接口的优势体现在:
①适合多个相同的程序代码的线程去共享同一个资源
②可以避免java中的单继承的局限性
③增加程序的健壮性,实现解耦操作,代码可以被多个线程共享,代码和线程独立
④线程池只能放入实现Runable或Callable类线程,不能直接放入继承Thread的类

3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?

线程安全问题的产生原因:
当多个线程去操作同一个资源,并对资源中的数据实行修改操作,就会出现线程安全问题

解决线程安全问题有三种方式
①同步代码块
②同步方法
③Lock锁

4.sleep()方法和wait()方法的区别?

sleep()方法:sleep()方法来源于Thread类,没有获取锁和释放锁的过程,sleep()方法必须给定一段休眠时间,休眠时间一到线程开始活动
wait()方法:wait()方法来源于Object类,有获取锁和释放锁的功能,wait()方法可以不给定休眠时间,如果没有给定休眠时间,
线程将永久睡眠,直到调用Object类中的notify()方法才能唤醒,继续活动
回复 使用道具 举报
1.多线程的实现有几种方式?实现步骤分别是怎样的?
两种,一种是继承Thread。(1) 定义Thread类的子类,并重写该类的run()方法,
该run()方法的方法体就代表了线程需要完成的任务,因此把 run()方法称为线程执行体。
(2) 创建Thread子类的实例,即创建了线程对象
(3) 调用线程对象的start()方法来启动该线程

一种是接口Runnable。(1) 定义Runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。
(2) 创建Runnable实现类的实例,并以此实例作为Thread的target来创建Thread对象,该Thread对象才是真正 的线程对象。
(3) 调用线程对象的start()方法来启动线程。

2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
区别:如果一个类继承Thread,则不适合资源共享。但是如果实现了Runable接口的话,则很容易的实现资源共享。
优势:适合多个相同的程序代码的线程去共享一个资源;可以避免JAVA中的单继承局限性;
增加程序的健壮性,实现解耦操作,代码可以被多个线程共享,代码和线程独立;
线程池只能放入实现Runnable或者Callable类线程,不能直接放入继承Thread的类。

3.线程安全问题是怎么产生的?如何解决线程安全问题,有哪几种方式?
线程安全问题都是由全局变量以及静态变量引起的,若每个线程中对全局变量,静态变量只有读操作,而无写操作,
一般来说,这个全局变量是线程安全的 ;若有多个线程同时执行写操作,一般都需要考虑线程同步,否则就可能影响线程安全。
有三种方式:同步代码块,同步方法,Lock锁,同步代码块用的最多。

4.sleep()方法和wait()方法的区别?
sleep()是Thread里的方法,wait()是Object里的方法;
sleep()执行,释放CPU不释放同步锁锁, wait()执行释放CPU和同步锁锁。
回复 使用道具 举报
1.多线程的实现有几种方式?实现步骤分别是怎样的?
答:
二种方式:
一、继承Thread类的方式实现(1)创建一个类让这个类extends Thread
                          (2)覆盖重写Thread类中的run()方法,创建线程任务
                          (3)在测试类中创建子类的对象
                          (4)子类对象调用父类中的start()方法  
二、实现Runnable接口(1)创建一个类让这个类implements Runnable
                    (2)覆盖重写Runnable类中的run()方法,创建线程任务
                    (3)在测试类中创建实现类的对象
                    (4)创建Thread类的对象
                    (5)将实现类对象作为参数传递至Thread类的构造方法中
                    (6)调用Thread类中的start()方法


2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
答:
继承Thread类和实现Runnable接口的区别:每个类只能有一个直接父类,可以实现多个接口,使用继承的方式,那么这个类就不能继承其他的类
实现Runnable接口的优势: 1.避免了单继承的局限性
                              一个类只能继承一个类(一个人只能有一个亲爹),类继承了Thread类就不能继承其他的类
                                实现了Runnable接口,还可以继承其他的类,实现其他的接口
                         2.增强了程序的扩展性,降低了程序的耦合性(解耦)
                               实现Runnable接口的方式,把设置线程任务和开启新线程进行了分离(解耦)


3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
答:
线程安全问题是多个线程共享同一个资源,并对这个资源的数据进行修改操作
有三种方式解决线程安全问题:
一、同步代码块,格式
     创建安全锁对象  Object obj = new Object();
        synchronize(obj){
            可能出现线程安全的代码
     }
二、使用同步方法,格式
    修饰符  synchronize 返回值 方法名(参数列表){
              
               可能出现线程安全的代码
              
   }
三、Lock(接口)锁,使用步骤:
    1.在成员位置创建一个ReentrantLock对象
    2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
    3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁

4.sleep()方法和wait()方法的区别?
答:
1.两个方法的来源不一样sleep方法来源于Thread类wait方法来自Object

2.wait方法调用后会释放锁对象和CPU执行权;sleep方法只释放CPU执行权





回复 使用道具 举报
1.多线程的实现有几种方式?实现步骤分别是怎样的?
答:有两种实现多线程的方式:
(1)继承Thread类,实现Thread类的run方法。随后在调用处建立子类的对象,并用子类的对象调用start方法,建立一条线程;
(2)实现Runnable接口,实现Runnable接口的run方法。随后在调用处建立实现类的对象,将对象传入Thread的有参构造方法中,建立Thread的子类对象,并通过其调用start方法,建立一条线程。

2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
答:继承Thread类只需要建立子类的对象,就可以调用start方法,建立线程。而实现Runnable的接口需要先建立实现类的对象,然后再将其作为参数传入Thread的有参构造方法中,建立Thread类的子类对象,借助Thread的子类对象调用start方法,建立线程。
优势:因为继承属于单继承,也就是说继承了Thread类后,该子类不能继承其他的类,而实现Runnable接口后,该类还可以继承其他的类,实现其他的接口。除此之外,实现Runnable接口可以实现资源共享。

3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
答:当多个线程共享一份数据资源时,并试图对该数据进行修改操作时很容易产生线程安全问题,即不同线程的执行顺序将产生不同的结果。解决线程安全问题一般有三种方式:
(1)同步代码块,synchronized 关键字用于方法中的某个区块中,表示只对这个区块的资源实行互斥访问。格式:synchronized(同步锁){需要同步操作的代码},多个线程必须使用同一把同步锁。
(2)同步方法,即使用synchronized修饰的方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。格式:public synchronized void method(){可能会产生线程安全问题的代码}。
(3)Lock锁,也称同步锁,将加锁与释放锁方法化了,用lock()方法加同步锁,用unlock()方法释放同步锁,在这两个方法之间的代码对线程具有排他性,即同一时间只允许一个线程执行该段代码。

4.sleep()方法和wait()方法的区别?
答:(1)wait方法是来源于Object类的方法,sleep是来源于Thread类的方法。
(2)wait方法调用之后,会释放锁对象和CPU的执行权;sleep方法不释放锁对象,只释放CPU执行权。
回复 使用道具 举报
1.多线程的实现有几种方式?实现步骤分别是怎样的?
两种
(1)继承Thread类
        1.子类继承Thread类
         2.重写Thread类的run方法
        3.在测试类中创建子类对象
        4.条用start方法开启线程
(2)实现Rannable接口
        1.实现类实现Runnable接口
        2.重写接口中的run方法
        3.在测试类中创建线程对象Thread,将实现类作为参数传递出去
        4.调用start方法开启线程       
2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
区别:如果一个类继承Thread,则不适合资源共享,但如果实现了Runnable接口的话,则很容易实现资源共享
优势:1.适合多个相同的程序代码的线程去共享同一个资源
           2.可以避免java中的单继承局限性
          3.增加程序的健壮性,实现解耦操作,代码可以被多个线程共享,代码和线程独立
          4.线程池只能放入实现Runable或Callable类线程,不能直接放入继承Thread的类。
3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
  线程安全问题:
      (1) 线程修改数据,会产生重复的数据
    (2)线程会产生不存在的数据
  解决方式:
       1.同步代码块  synchronized(同步锁){需要同步操作的代码}  注意事项:同步代码块的锁对象可以是任意对象,但必须保证多个线程的锁对象是一个。
        2.同步方法  public synchronized void meth(){可能会产生线程安全问题的代码}     锁的对象是this
        3.静态的同步方法   public static synchronized void method(){可能会产生线程问题的代码}    锁的对象是类名 .class
4.sleep()方法和wait()方法的区别?
Sleep方法来源于Thread类,让线程进入睡眠,指定睡眠时间,时间到了以后,自动苏醒。sleep方法
进入到睡眠不会释放锁对象。
wait方法来源于Object类,让线程进入等待,指定等待时间,或者不指定知道其他线程唤醒。wait方法
会释放锁对象,wait方法想要继续执行,必须获得到其他线程的锁对象并抢到CPU执行权。
回复 使用道具 举报
1.多线程的实现有几种方式?实现步骤分别是怎样的?
答:两种分别是继承Thread类来创建和定义Runnable接口的实现类;
Thread类:1. 定义Thread类的子类,并重写该类的run()方法,该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。2. 创建Thread子类的实例,即创建了线程对象3. 调用线程对象的start()方法来启动该线程
Runnable接口:1. 定义Runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。2. 创建Runnable实现类的实例,并以此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象。3. 调用线程对象的start()方法来启动线程

2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
答:
1. 适合多个相同的程序代码的线程去共享同一个资源。
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性,实现解耦操作,代码可以被多个线程共享,代码和线程独立。
4. 线程池只能放入实现Runable或Callable类线程,不能直接放入继承Thread的类

3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
答:线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作,而无写操作,一般来说,这个全局变量是线程安全的;若有多个线程同时执行写操作,一般都需要考虑线程同步,否则的话就可能影响线程安全
三种方式解决:同步代码块,synchronized 关键字可以用于方法中的某个区块中,表示只对这个区块的资源实行互斥访问;同步方法,使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着;Lock锁,lock()加同步锁unlock() :释放同步锁

4.sleep()方法和wait()方法的区别?
答:sleep()方法导致了程序暂停执行指定的时间,让出cpu该其他线程,但是他的监控状态依然保持者,当指定的时间到了又会自动恢复运行状态。在调用sleep()方法的过程中,线程不会释放对象锁。而当调用wait()方法的时候,线程会放弃对象锁,进入等待此对象的等待锁定池,只有针对此对象调用notify()方法后本线程才进入对象锁定池准备
回复 使用道具 举报
1.多线程的实现有几种方式?实现步骤分别是怎样的?

两种
(1)继承Thread类  
<1>首先新建一个继承类继承Thread类
<2>在继承类中重写Thread类中的run方法,在run方法中写任务模块
<3>创建继承类对象
<4>用继承类对象调用start方法来开启线程

(2)实现Runnable接口
<1>首先新建一个接口实现类
<2>重写Runnable接口的run方法,在run方法中写任务模块
<3>创建接口实现类对象
<4>创建Thread对象,传入接口实现类对象作为参数
<5>用Thread对象调用start方法开启线程

2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?

<1>继承Thread类占用了继承位,无法实现其他继承关系;而Runnable接口是实现类,不影响继承。
<2>继承Thread类子类既需要穿件对象,又有线程任务,耦合度太高;而Runnable接口只是实现线程的任务功能,
<3>继承Thread类多个对象无法共享资源;而Runnable接口可以创建多个对象是,实现资源共享。
所以,Runnable接口避免了单继承性的局限性,又降低了耦合度

3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?

线程的安全是在多个线程同时访问修改共享资源的时候产生的
我们可以通过提取共享模块,然后给共享模块加锁来限制访问线程的数量,从而解决线程安全问题。
主要有三中方式:
<1>在共享模块前加上synchronize关键字;
<2>提取共享模块,将模块放在方法中,在方法上加synchronize关键字;
<3>Lock接口实现类ReentrantLock,通过实现类对象调用lock方法加锁,unlock释放锁。

4.sleep()方法和wait()方法的区别?

<1>sleep方法时Thread类中;wait是Object类中的方法。
<2>sleep方法在执行时是释放CPU执行权,不会释放锁对象;wait方法执行是,不仅会释放CPU执行权,还会释放锁对象。
回复 使用道具 举报
1.多线程的实现有几种方式?实现步骤分别是怎样的?
多线程的实现有两种方式,一种是通过继承,另一种是通过接口实现
继承:创建一个子类,继承Thread,重写父类中的run()方法,创建对象,开启线程
接口:创建一个接口实现类,实现Runnable接口,重写run()方法,创建对象,
再创建Thread将创建的对象传入Thread中,开启线程

2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
继承:创建的每一个线程都是一个崭新的线程
实现:一个线程对象可以多次被开启
实现的优势:同一个线程可以多次被开启,一个子类只能继承一个父类,继承Thread会占用继承父类

3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
线程安全问题时怎么产生的:同一块代码区域被多条线程进行改写造成的线程安全问题;
如何解决线程安全问题:通过加synchronized来解决线程安全问题;有三种方式解决;
1)同步代码块
2)同步方法
3)锁机制

4.sleep()方法和wait()方法的区别?
sleep()属于Thread,wait()属于Object,sleep()休眠期间不会归还锁,wait()休眠期间会归还锁
回复 使用道具 举报
王佳盛
1.        多线程的实现有几种方式?实现步骤分别是怎样的?
有两种方式:
第一种方式:继承Thread类
(1)        自定义一个Thread的子类
(2)        重写run()方法
(3)        测试类中创建Thread子类对象,调用start()方法开启新线程
第二种方式:实现Runnable接口
(1)        创建Runnable的实现类
(2)        测试类中创建Runnable的实现类对象
(3)        创建Thread对象,调用带参构造方法传入Runnable实现类对象作为参数
(4)        调用start()方法开启新线程

2.        继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
继承Thread类:占用了继承位;在Thread之类中重写run()方法,不能够实现多个线程执行同一段代码。耦合度太高。
实现Runnable接口:实现了Runnable接口还能继承其它类,在Runnable实现类重写run()方法,通过构造方法传入Runnable实现类对象作为参数创建Thread类对象调用start()方法开启新线程,可以实现多个线程执行同一段代码,降低了耦合度。
优势:
(1)        避免了单继承的局限性
(2)        增强了程序的扩展性,降低了程序的耦合性
(3)        实现了Runnable接口的方式,将线程任务和开启新线程进行了分离。

3.        线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
当我们要用多个线程对共享数据进行修改的时候,由于CPU的是高速在多个线程之间切换执行的,所以在修改共享数据的时候就有可能出现问题(例如:卖票案例中,出现了一张票被卖了多次等)
解决方案:
第一种方式:同步代码块
        将可能会出现线程安全问题的代码抽取到synchronize代码块中
        格式 : synchronize(锁对象){可能会出现问题的代码}
第二种方式:同步方法
        把访问了共享数据的代码抽取到一个方法中,并用synchronize修饰该方法
        格式:修饰符 synchronize 返回值类型 方法名(参数列表){ 方法体 }
第三种方式:Lock锁
(1)        在成员位置创建一个ReentrantLock对象
(2)        在可能出现安全问题的代码前调用Lock接口中的lock()方法获取锁
(3)        在可能出现安全问题的代码后调用Lock接口中的unlock()方法释放锁

4.sleep()方法和wait()方法的区别?
sleep():线程失去CPU执行权,但仍然拥有锁对象。只有当线程执行完成同步代码,才会释放锁对象
wait():线程失去CPU执行权,并立即释放锁对象。若方法中没有传入参数,则线程进入无限等待状态。等待被notify()唤醒。若方法中传入参数x,则方法在等待x毫秒后被唤醒重新进入阻塞状态,等待争抢CPU执行权

回复 使用道具 举报
1.多线程的实现有几种方式?实现步骤分别是怎样的?
    (1)一种是继承Thread类方式
    步骤是:
    a. 创建一个Thread类的子类
    b. 在Thread类的子类中重写Thread类中的run方法,设置线程任务
    c. 创建Thread类的子类对象
    d. 调用Thread类中的方法start方法,开启新的线程,执行run方法

   (2)一种是实现Runnable接口方式
   步骤:
    a. 创建一个Runnable接口的实现类
    b. 在实现类中重写Runnable接口的run方法,设置线程任务
    c. 创建一个Runnable接口的实现类对象
    d. 创建Thread类对象,构造方法中传递Runnable接口的实现类对象
    e. 调用Thread类中的start方法,开启新的线程执行run方法

2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
     如果一个类继承Thread,则不适合资源 共享。但是如果实现了Runable接口的话,则很容易的实现资源共享。
     实现Runnable接口比继承Thread类所具有的优势:
(1) 适合多个相同的程序代码的线程去共享同一个资源。
(2) 可以避免java中的单继承的局限性。
(3) 增加程序的健壮性,实现解耦操作,代码可以被多个线程共享,代码和线程独立。
(4)线程池只能放入实现Runable或Callable类线程,不能直接放入继承Thread的类

3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
前提:多个线程在执行同一资源并对资源进行数据的修改
产生的安全问题:a.线程修改数据,会产生重复的数据;b.线程会产生不存在的数据
解决方式:a.同步代码块
          b.同步方法
          c.Lock锁

4.sleep()方法和wait()方法的区别?
    sleep()方法使当前正在执行的线程以指定的毫秒数暂停(暂时停止执行)。
     wait()方法,无限期等待另一个线程执行一个特别的(唤醒)动作的线程
     sleep()方法源于Thread类让线程进入睡眠,指定了睡眠时间,时间一到自动苏醒。它进入到睡眠不会释放对象。
      wait()方法源于Object类,让线程进入等待,指定等待时间或者不指定知道其他线程唤醒。wait方法会释放锁对象,wait方法想要继续执行,必须获得到其他线程的锁对象并抢到CPU执行权


回复 使用道具 举报
1.多线程的实现有几种方式?实现步骤分别是怎样的?
答:有两种实现多线程的方式:
(1)继承Thread类,实现Thread类的run方法。随后在调用处建立子类的对象,并用子类的对象调用start方法,建立一条线程;
(2)实现Runnable接口,实现Runnable接口的run方法。随后在调用处建立实现类的对象,将对象传入Thread的有参构造方法中,建立Thread的子类对象,并通过其调用start方法,建立一条线程。

2.继承Thread类和实现Runnable接口有啥区别?实现Runnable接口的优势体现在哪里?
答:继承Thread类只需要建立子类的对象,就可以调用start方法,建立线程。而实现Runnable的接口需要先建立实现类的对象,然后再将其作为参数传入Thread的有参构造方法中,建立Thread类的子类对象,借助Thread的子类对象调用start方法,建立线程。
优势:因为继承属于单继承,也就是说继承了Thread类后,该子类不能继承其他的类,而实现Runnable接口后,该类还可以继承其他的类,实现其他的接口。除此之外,实现Runnable接口可以实现资源共享。

3.线程安全问题时怎么产生的?如何解决线程安全问题,有哪几种方式?
答:当多个线程共享一份数据资源时,并试图对该数据进行修改操作时很容易产生线程安全问题,即不同线程的执行顺序将产生不同的结果。解决线程安全问题一般有三种方式:
(1)同步代码块,synchronized 关键字用于方法中的某个区块中,表示只对这个区块的资源实行互斥访问。格式:synchronized(同步锁){需要同步操作的代码},多个线程必须使用同一把同步锁。
(2)同步方法,即使用synchronized修饰的方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。格式:public synchronized void method(){可能会产生线程安全问题的代码}。
(3)Lock锁,也称同步锁,将加锁与释放锁方法化了,用lock()方法加同步锁,用unlock()方法释放同步锁,在这两个方法之间的代码对线程具有排他性,即同一时间只允许一个线程执行该段代码。

4.sleep()方法和wait()方法的区别?
答:(1)wait方法是来源于Object类的方法,sleep是来源于Thread类的方法。
(2)wait方法调用之后,会释放锁对象和CPU的执行权;sleep方法不释放锁对象,只释放CPU执行权。
回复 使用道具 举报
123下一页
您需要登录后才可以回帖 登录 | 加入黑马