其他分享
首页 > 其他分享> > 多线程之一

多线程之一

作者：互联网

朝花夕拾：多线程

多线程的优点

以单核CPU为例，只使用单个线程先后完成多个任务（调用多个方 法），肯定比用多个线程来完成用的时间更短，为何仍需多线程呢？

多线程程序的优点：

  1. 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。

  2. 提高计算机系统CPU的利用率

  3. 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

何时需要多线程

多线程的创建

继承于Thread

/**
 * 1.创建一个继承于Thread的类
 * 2.重写run方法-->将此线程的操作写在这里
 * 3.创建thread类的子类对象
 * 4.通过该对象调用start方法
 */
public class ThreadTest{
    public static void main(String[] args){
        Demo01 demo01 = new Demo01();
        //启动当前线程，并调用run()方法
        demo01.start();
        //主线程
        for (int i = 1; i <= 100; i++) {
            if(i%2==0){
                System.out.println(i+"****");
            }
        }
    }
}
/**
 * 这个线程用来遍历1-100的偶数。
 */
class Demo01 extends Thread{
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            if(i%2==0){
                System.out.println(i);
            }
        }
    }
}

实现Runnable接口

public class ThreadTest1 {
    public static void main(String[] args) {
        //3.创建实现类的对象
        Demo02 demo02 = new Demo02();
        //4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread thread = new Thread(demo02);
        //5.通过Thread类的对象调用start()
        thread.start();
        for (int i = 0; i <=100; i++) {
            if(i%2!=0){
                System.out.println(i+"hello");
            }
        }
    }
}
//1.创建一个实现了Runnable接口的类
class Demo02 implements Runnable{
    //2.实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
        for (int i = 0; i <=100; i++) {
            if(i%2==0){
                System.out.println(i);
            }
        }
    }
}

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

开发中：优先选择：实现Runnable接口的方式

原因：

继承方式和实现方式的联系与区别

public class Thread extends Object implements Runnable

Thread类的特性

Thread类

测试Thread中的常用方法：

线程的调度

Java的调度方法

线程优先级

设置线程优先级

Thread.currentThread().setPriority(Thread.MAX_PRIORITY);

说明：

线程的生命周期

JDK中用Thread.State类定义了线程的几种状态

image-20220401225329019

线程同步

image-20220401232141465

多线程出现了安全问题
问题的原因：

同步代码块

synchronized(同步监视器){
       //需要被同步的代码
}
/*  说明：1.操作共享数据的代码，即为需要被同步的代码。  -->不能包含代码多了，也不能包含代码少了。
 *       2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。
 *       3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
 *      要求：多个线程必须要共用同一把锁。
 */

同步方法

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。

在方法上使用关键字：synchronized

死锁问题

死锁

Lock

//空参构造
private Lock lock = new ReentrantLock();
//有参构造
//公平锁
private Lock lock = new ReentrantLock(true);
//非公平锁
private Lock lock = new ReentrantLock(false);

public class ThreadTest2 {
    public static void main(String[] args) {
        Window01 window01 = new Window01();
        Thread t1 = new Thread(window01);
        Thread t2 = new Thread(window01);
        Thread t3 = new Thread(window01);
        t1.setName("线程1");
        t2.setName("线程2");
        t3.setName("线程3");
        t1.start();
        t2.start();
        t3.start();

    }
}
class Window01 implements Runnable{
    private ReentrantLock lock = new ReentrantLock(true);
    private int ticket=100;
    @Override
    public void run() {
        while (true){
            try {
                //上锁
                lock.lock();
                if(ticket>0){
                    try {
                        Thread.sleep(100);
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"：票号为："+ticket);
                    ticket--;
                }else {
                  break;
                }
            } finally {
                //解锁
                lock.unlock();
            }
        }
    }
}

标签：之一,run,Thread,对象,start,线程,new,多线程
来源： https://www.cnblogs.com/Boerk/p/16089927.html