Java多线程

最新推荐文章于 2024-07-23 21:45:09 发布

举高

最新推荐文章于 2024-07-23 21:45:09 发布

阅读量48

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/qq_43649569/article/details/120751279

版权

思考：synchronized 和 Lock 的异同？

一.创建方式

多线程创建方式 (1)

1.写一个类继承Thread类。

2.重写里面的run()方法，将此线程需要执行的操作声明在run中。

3.创建Thread子类的对象，通过对象调用start() 。

//start()只能调用一次，如果再想调用，就再new一个对象。

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

1.start():启动当前线程，调用run()方法。

2.run()：通常需要重写Thread类中的此方法，将将此线程需要执行的操作声明在run中。

3.currentThread()：静态方法，返回执行当前代码的线程。

4.setName()：设置当前线程的名字。

5.getName():获取当前线程的名字。

6.yield()：暂停当前正在执行的线程对象，并执行其他线程。

7.join() :等待该线程终止。或者在a线程中调b线程，a线程进入阻塞状态，则等b执行完再执行a

8.sleep( ) : 在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。

9.setPriority( )：更改线程优先级d

多线程创建方式 (2)

1.创建一个实现Runnable接口的类

2.在类中去实现Runnable中的抽象方法run( )；

3.创建实现类的对象

4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象

5.通过Thread类的对象调用start( )；

买票窗口举例：

public class Exercise01 {
    public static void main(String[] args) {
        Window window = new Window();
        Thread t1 = new Thread(window);
        Thread t2 = new Thread(window);
        Thread t3 = new Thread(window);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

class Window implements Runnable {
    private  int ticket = 100;
    @Override
    public void run() {
        while (true) {
            if (ticket>0){
                System.out.println(Thread.currentThread().getName()+
                        "卖出的票号为"+ticket);
                ticket--;
            }else {
                break;
            }
        }
    }
}

比较创建线程的两种方式。

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

二.使用同步时的代码

(1).同步方法

即有synchronized关键字修饰的方法。由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。

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

        Window window = new Window();
        Thread t1 = new Thread(window);
        Thread t2 = new Thread(window);
        Thread t3 = new Thread(window);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

class Window implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            show();
            if(ticket==0){
                break;
            }
        }
    }
    public synchronized void  show(){
        if (ticket > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() +
                    "卖出的票号为" + ticket);
            ticket--;
        }
    }
}

(2).同步代码块

即有synchronized关键字修饰的语句块。被该关键字修饰的语句块会自动被加上内置锁，从而实现同步注意：Window.class 表示自身的对象

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

        Window window = new Window();
        Thread t1 = new Thread(window);
        Thread t2 = new Thread(window);
        Thread t3 = new Thread(window);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

class Window implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            synchronized (Window.class) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() +
                            "卖出的票号为" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

(3).Lock锁

1.实例化ReentrantLock

2. 使用lock()方法获取锁，使用unlock()方法释放锁。(一般在try finally中)

import java.util.concurrent.locks.ReentrantLock;

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

        Window window = new Window();
        Thread t1 = new Thread(window);
        Thread t2 = new Thread(window);
        Thread t3 = new Thread(window);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

class Window implements Runnable {
    private int ticket = 100;
    private ReentrantLock lock = new ReentrantLock(true);

    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();
                if (ticket > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() +
                            "卖出的票号为" + ticket);
                    ticket--;
                } else {
                    break;
                }
            } finally {
                lock.unlock();
            }
        }
    }
}

思考：synchronized 和 Lock 的异同？

相同：二者都可以解决线程安全问题

不同：synchronized 在执行完相应同步代码后，自动的释放同步监视器

Lock 需要手动的启动同步（lock()），结束同步（unlock()）

举高

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java多线程

一.创建方式多线程创建方式 (1)1.写一个类继承Thread类。2.重写里面的run()方法，将此线程需要执行的操作声明在run中。3.创建Thread子类的对象，通过对象调用start() 。 //start()只能调用一次，如果再想调用，就再new一个对象。public class Exercise { public static void main(String[] args) { MyThread t1 = new MyThread(); ..
复制链接

扫一扫