继承Thread类以及实现Runable接口
方式一:继承于Thread类
步骤:
1.创建一个继承于Thread类的子类
2.重写Thread类的run()----->将此线程执行的操作声明在run()中
3.创建Thread类的子类的对象
4.通过此对象调用start()
举例:遍历100以内的所有的偶数.
代码:
//1.创建一个继承于Thread类的子类
class MyThread extends Thread {
//重写Thread类的run()
@Override
public void run() {
for (int i=0;i<100;i++){
if(i%2==0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
public class ThreadTest {
public static void main(String[] args) {
//3.创建Thread类的子类对象
MyThread t1 = new MyThread();//快捷键:alt+enter
//通过对象调用start()
t1.start();//start()两个作用:1.启动当前线程 2.调用当前的run();
//如下的方法仍然是在main线程中执行的
MyThread t2 = new MyThread();
t2.start();
for (int i=0;i<100;i++){
if(i%2==0){
System.out.println(Thread.currentThread().getName()+":hello");
}
}
}
}
方式二:实现Runable接口
步骤:
1.创建一个 实现 了Runnable接口的类
2.实现类去实现Runnable中的抽象方法:run()
3.创建实现类的对象
4.将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象
5.通过Thread类的对象调用start().
代码:
//1.创建一个 实现 了Runnable接口的类
class MTherad implements Runnable{
// 2.实现类去实现Runnable中的抽象方法:run()
@Override
public void run() {
for (int i = 0; i <100 ; i++) {
if(i%2==0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
public class ThreadTest1 {
public static void main(String[] args) {
//3.创建实现类的对象
MTherad mTherad = new MTherad();
//4.将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象
Thread t1 = new Thread(mTherad);
t1.setName("线程1");
//5.通过Thread类的对象调用start()
t1.start();
Thread t2 = new Thread(mTherad);
t2.setName("线程2");
t2.start();
}
}
注意: 上述两种创建多线程的方式并没有解决线程安全问题!!!
解决线程安全问题的三种方式:
举例:创建
1.同步代码块
synchronize(同步监视器){
//需要被同步的代码
}
说明:
1.操作共享数据的代码,即为需要被同步的代码
2.共享数据:多个线程共同操作的变量,比如:ticket
3.同步监视器,俗称:锁. 任何一个类的对象,都可以充当锁.
要求:多个线程必须要共用一把锁.
使用同步代码块解决实现Runable接口线程安全问题:
class Window1 implements Runnable {
private int ticket = 100;
Object obj=new Object();
Dog dog=new Dog();
@Override
public void run() {
// Object obj=new Object(); 放这里不行,因为三个线程都会new一个对象(锁),锁需要共用
while (true) {
// synchronized (dog) {//任何一个类的对象,都可以充当锁,dog或者obj都可以,最简单的就是用this
synchronized (this){//此时的this:唯一的window1的对象
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":卖票,票号为" + ticket);
ticket--;
} else {
break;
}
}
}
}
}
public class WindowTest1 {
public static void main(String[] args) {
Window1 w1 = new Window1();
Thread t1 = new Thread(w1);
Thread t2 = new Thread(w1);
Thread t3 = new Thread(w1);
t1.setName("线程1");
t2.setName("线程2");
t3.setName("线程3");
t1.start();
t2.start();
t3.start();
}
}
class Dog{//自定义一个类也可以充当锁
}
使用同步代码块解决继承Thread类的方式的线程安全问题:
class Window2 extends Thread{
private static int ticket=100;
// Object obj= new Object();//这时候会在main中new三个对象,不是共用同一把锁
private static Object obj=new Object();//加上static就是共用一把锁了
@Override
public void run() {
while(true){
// synchronized (obj){//正确
synchronized (Window2.class){
// synchronized (this){//错误:this代表着t1,t2,t3三个不同的对象,不符合锁的要求
if(ticket>0){
System.out.println(Thread.currentThread().getName()+":卖票,票号为:"+ticket);
ticket--;
}else{
break;
}
}
}
}
}
public class WindowTest2 {
public static void main(String[] args) {
Window2 t1 = new Window2();
Window2 t2 = new Window2();
Window2 t3 = new Window2();
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
2.同步方法
操同步代码时,只能有一个线程完整的声明在一个方法中,我们不妨将此方法声明同步的.
使用同步方法解决实现Runnable接口的线程安全问题
class Window3 implements Runnable {
private int ticket = 100;
@Override
public void run() {
while (true) {
show();
}
}
private synchronized void show(){//只需将方法声明称synchronize即可,不需要像之前那样包起来 同步监视器:this
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":卖票,票号为" + ticket);
ticket--;
}
}
}
public class WindowTest3 {
public static void main(String[] args) {
Window1 w1 = new Window1();
Thread t1 = new Thread(w1);
Thread t2 = new Thread(w1);
Thread t3 = new Thread(w1);
t1.setName("线程1");
t2.setName("线程2");
t3.setName("线程3");
t1.start();
t2.start();
t3.start();
}
}
使用同步方法处理继承Thread类的方式中的线程安全问题
class Window4 extends Thread{
private static int ticket=100;
@Override
public void run() {
while(true){
show();
}
}
private static synchronized void show(){//同步监视器;Window4.class
// private synchronized void show(){//同步监视器:t1,t2,t3,c此种方式错误
if(ticket>0){
try {
Thread.sleep(100);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":卖票,票号为:"+ticket);
ticket--;
}
}
}
public class WindowTest4 {
public static void main(String[] args) {
Window4 t1 = new Window4();
Window4 t2 = new Window4();
Window4 t3 = new Window4();
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
关于比较创建线程的两种方式: 在Thread类跟Runnable接口
开发中优先选择 实现Runnable接口的方式.
原因:
1.实现的方式没有类的单继承性的局限性
2.实现的方式更适合来处理多个线程有共享数据的情况
联系:
Thread本身也是实现Runnable(public class Thread implements Runnable ).
相同点: 两种方式都需要重写run(),将线程要执行的逻辑声明在run()中.
关于同步方法的总结:
1.同步方法仍然涉及到同步监视器,只是不需要我们现实的声明
2.非静态的同步方法中,同步监视器是:this; 静态的同步方法中,同步监视器是:当前类本身.
3.lock锁
.1.synchronize 与Lock的异同?
相同: 二者都可以解决线程安全问题
不同:
①synchronize机制在执行完相应的同步代码以后,自动的释放同步监视器.
⑤Lock需要手动的启动同步(lock()),同时结束同步也需要手动的实现(unlock()).
2.优先使用顺序:
- Lock—>同步代码块(已经进入方法体,分配了相应资源)—>同步方法(在方法体外)
代码:
class Window implements Runnable{
private int ticket=100;
//1.实例化ReentrantLock
private ReentrantLock lock=new ReentrantLock(false);//默认是false,可以不写,非公平锁 查看方法里面参数 ctrl+shift +空格
@Override
public void run() {
while(true){
try {
//2.调用锁定方法:lock()
lock.lock();
if (ticket>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":售票,票号为:"+ticket);
ticket--;
}else{
break;
}
}finally {
//3.调用解锁:unlock
lock.unlock();
}
}
}
}
public class LockTest {
public static void main(String[] args) {
Window w=new Window();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
1027
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
