kafka和zookeeper的配置

Linux学习日志1.6:其他权限管理命令

  返回  

13.Java多线程

2021/8/20 17:16:42 浏览:

概念

并发与并行

并发:指两个或多个事件在同一时间段内发生

并行:指两个或多个事件在同一时刻发生(同时发生)

线程与进程

进程:是指一个内存中运行的应用程序

线程:线程是进程中的一个执行单元,一个进程至少有一个线程

创建线程类

主线程:执行主(main)方法的线程

单线程程序:java程序只有一个线程
执行从main方法开始 从上到下依次执行

Thread

步骤:

  1. 创建Thread类的子类
  2. 在子类中重写run()方法 设置线程任务
  3. 创建子类对象
  4. 调用Thread类中的start()方法,开启新线程,执行run方法

start():使该线程开始执行,java虚拟机调用该线程的run()方法

//创建Thread类的子类
public class MyThread extends Thread {
    @Override
    public void run() {
        for(int i = 0;i<20;i++){
            System.out.println("run:"+i);
        }
    }
}


public class ThreadDemo {
    public static void main(String[] args) {
    //创建子类对象
        MyThread myThread = new MyThread();
        myThread.start();

        for(int i = 0;i<20;i++){
            System.out.println("main:"+i);
        }
    }
}

Thread 常用方法

获取线程名称:

  • Thread类中的getName()方法
  • 获取当前执行的线程,使用线程中的方法getName(),currentThread()返回当前执行线程的引用
 @Override
    public void run() {
        String name = getName();
        System.out.println(name);
    }
  
  //可以在主方法(main里)输出打印main线程名字  
   System.out.println(Thread.currentThread().getName());

设置线程名称:

  1. 使用Thread类中的setName()方法
  2. 创建带参数的构造方法,参数传递线程的名称,调用父类的带参构造方法,把线程名字传递给父类

sleep: 使当前执行的线程以指定的毫秒数暂停

创建线程第二种方法 实现Runnable接口

Thread类的构造方法可以传递Runnable实现类对象

实现步骤:

  1. 创建一个Runnable接口的实现类
  2. 在实现类中重写Runnable接口的run方法
  3. 创建一个Runnable接口的实现类对象
  4. 创建一个Thread类对象,构造方法中传递Runnable接口的实现类对象
  5. 调用Thrad类中的start()方法
//创建一个Runnable接口的实现类
public class RunnableImpl implements  Runnable {
    //在实现类中重写Runnable接口的run方法
    @Override
    public void run() {
        for (int i = 0;i<20;i++){
            System.out.println(i);
        }
    }
}

 public static void main(String[] args) {
        //创建一个Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        //创建一个Thread类对象,构造方法中传递Runnable接口的实现类对象
        Thread t = new Thread(run);
        //调用Thrad类中的start()方法
        t.start();
    }

Thread 与 Runnable区别

实现Runnable接口创建多线程的好处:

  1. 避免了单继承 (实现了Runnable 还能继承其他类)
  2. 增强了程序的扩展性(设置线程任务和开启新线程进行分离)

匿名内部类创建线程

简化代码

格式:

new 父类/接口(){

重写父类/接口方法

};


  public static void main(String[] args) {
        //线程的父类是Thread
        new Thread(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"KK");
            }
        }.start();

        //线程的接口Runnable
        Runnable r = new Runnable(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"RR");
            }
        };
        new Thread(r).start();

        //简化Runnable
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"R");
            }
        }).start();

    }

线程安全问题

单线程不会出现线程安全,多个线程对象操作共享资源就可能会出现线程安全问题

解决线程安全:

同步代码块:

synchronized(锁对象){
    可能出现线程安全问题的代码
}

注意:

  1. 通过代码块中的锁对象(可以是任意一个)
  2. 必须保证多个线程使用的锁对象是同一个
  3. 锁对象作用:把同步代码块锁住,只让一个线程在执行

同步技术:使用一个锁对象(同步锁),同步中的线程,没用执行完毕不会释放锁,
没有锁的线程进不去同步

同步方法

  1. 把访问共享数据的代码抽取出来,放在一个方法中
  2. 在方法上添加synchronized修饰符
修饰符 synchronized void 方法名(){
    可能出现线程安全问题的代码
}

静态同步方法

锁对象:本类的class属性

修饰符 static  synchronized void 方法名(){
    可能出现线程安全问题的代码
}

Lock锁

lock():获得锁

unlock():释放锁

使用步骤:使用它的实现类 ReentrantLock

  1. 在成员位置创建一个ReentrantLock对象
  2. 在可能会出现线程问题的代码前调用Lock接口的lock获取锁
  3. 在可能会出现线程问题的代码后调用Lock接口的unlock释放锁

线程的状态

六种状态:

  1. New(新建状态 new Thread)
  2. Runnable (运行状态)
  3. Blocked(阻塞状态)
  4. waiting(等待状态)
  5. time_waiting(休眠状态)
  6. Teaminated(退出状态)

联系我们

如果您对我们的服务有兴趣,请及时和我们联系!

服务热线:18288888888
座机:18288888888
传真:
邮箱:888888@qq.com
地址:郑州市文化路红专路93号