Java 多线程编程

最新推荐文章于 2024-05-04 18:28:36 发布
最新推荐文章于 2024-05-04 18:28:36 发布
阅读量477 收藏
点赞数 1
分类专栏： java se进阶学习 文章标签： 面试 职场和发展 java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43536259/article/details/121327149
版权

Java 多线程编程

程序(program) 是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

进程(process) 是程序的一次执行过程，或是正在运行的一个程序。是一个动态 的过程：有它自身的产生、存在和消亡的过程。——生命周期

  • 如：运行中的QQ，运行中的MP3播放器
  • 程序是静态的，进程是动态的
  • 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。

  • 若一个进程同一时间并行执行多个线程，就是支持多线程的
  • 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开 销小
  • 一个进程中的多个线程共享相同的内存单元/内存地址空间它们从同一堆中分配对象，可以 访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资 源可能就会带来安全的隐患。

Java 给多线程编程提供了内置的支持。 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。

这里定义和线程相关的另一个术语 - 进程：一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立的存在，它必须是进程的一部分。一个进程一直运行，直到所有的非守护线程都结束运行后才能结束。

多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。

单核CPU和多核CPU的理解

  • 单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。例如：虽然有多车道，但是收费站只有一个工作人员在收费，只有收了费 才能通过，那么CPU就好比收费人员。如果有某个人不想交钱，那么收费人员可以 把他“挂起”（晾着他，等他想通了，准备好了钱，再去收费）。但是因为CPU时间单元特别短，因此感觉不出来。
  • 如果是多核的话，才能更好的发挥多线程的效率。（现在的服务器都是多核的）
  • 一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc() 垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

并行与并发

  • 并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
  • 并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事。

何时需要多线程 ?

  • 程序需要同时执行两个或多个任务。
  • 程序需要实现一些需要等待的任务时，如用户输入、文件读写 操作、网络操作、搜索等。
  • 需要一些后台运行的程序时。

一个线程的生命周期

线程是一个动态执行的过程，它也有一个从产生到死亡的过程。

下图显示了一个线程完整的生命周期。

  • 新建状态:

    使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。

  • 就绪状态:

    当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。

  • 运行状态:

    如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。

  • 阻塞状态:

    如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：

    • 等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。

    • 同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。

    • 其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。

  • 死亡状态:

    一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。

线程的优先级

  • 每一个 Java 线程都有一个优先级，这样有助于操作系统确定线程的调度顺序

  • Java 线程的优先级是一个整数，其取值范围是 1 （Thread.MIN_PRIORITY ） - 10 （Thread.MAX_PRIORITY ）

  • 默认情况下，每一个线程都会分配一个优先级 NORM_PRIORITY（5）

  • 可以通过getPriority()来获取当前线程的优先级

  • 也可以通过setPriority(int newPriority)来改变线程的优先级

具有较高优先级的线程对程序更重要，并且应该在低优先级的线程之前分配处理器资源。但是，线程优先级不能保证线程执行的顺序，而且非常依赖于平台。

创建一个线程

Java 提供了三种创建线程的方法：

  • 通过实现 Runnable 接口；
  • 通过继承 Thread 类本身；
  • 通过 Callable 和 Future 创建线程。

1. 通过实现 Runnable 接口来创建线程

创建一个线程，最简单的方法是创建一个实现 Runnable 接口的类。

为了实现 Runnable，一个类只需要执行一个方法调用 run()，声明如下：

public  void  run()

你可以重写该方法，重要的是理解的 run() 可以调用其他方法，使用其他类，并声明变量，就像主线程一样。

在创建一个实现 Runnable 接口的类之后，你可以在类中实例化一个线程对象。

Thread 定义了几个构造方法，下面的这个是我们经常使用的：

Thread(Runnable  threadOb,String  threadName);

这里，threadOb 是一个实现 Runnable 接口的类的实例，并且 threadName 指定新线程的名字。

新线程创建之后，你调用它的 start() 方法它才会运行。

void  start();

###　方式：

实现Runnable接口

  • 定义子类，实现Runnable接口。

  • 子类中重写Runnable接口中的run方法。

  • 创建Runnable子类的对象

  • 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。

  • 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。

下面是一个创建线程并开始让它执行的实例：

实例

ThreadTest1文件：

/**
 * 方式二：使用 Runnable 接口实现
 * 1.定义子类，实现Runnable接口。
 * 2.子类中重写Runnable接口中的run方法。
 * 3.创建Runnable子类的对象。
 * 4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。
 * 5.调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。
 * @author Token
 * @create 2021-11-13 21:50
 */
public class ThreadTest1{
    public static void main(String[] args) {
        //3.通过Thread类含参构造器创建线程对象。
        Runnable m1 = new myThread();

        //4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。
        Thread t1 = new Thread(m1);
        //5.调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。
        t1.start();
    }

}

myThread文件：

//1.定义子类，实现Runnable接口。
class myThread implements Runnable{

    //2.子类中重写Runnable接口中的run方法。
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0 ){
                System.out.println(i);
            }
        }
    }
}

编译以上程序运行结果如下：

image-20211113220148877

需要创建第二个线程时，只需要再次创建一个Thread对象(参数可以是同一个Runnable对象)接口

Thread t2 = new Thread(m1);
//5.调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。
t2.start();

2. 通过继承Thread来创建线程

创建一个线程的第二种方法是创建一个新的类，该类继承 java.lang.Thread 类，然后创建一个该类的实例。

继承类必须重写 run() 方法，该方法是新线程的入口点。它也必须调用 start() 方法才能执行。

该方法尽管被列为一种多线程实现方式，但是本质上也是实现了 Runnable 接口的一个实例。

方式：

  1. 创建一个继承于Thread类的子类
  2. 重写Thread类的run()方法，将此线程执行的操作声明在run()中
  3. 创建Thread类的子类对象
  4. 通过此对象调用start()方法，start()的作用：1. 启动当前线程 2. 调用当前线程的run（）

注意点

  1. 如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。
  2. run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU 调度决定。
  3. 想要启动多线程，必须调用start方法。
  4. 一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上 的异常“IllegalThreadStateException”。

###　Threaad类的构造器

  • Thread()：创建新的Thread对象
  • Thread(String threadname)：创建线程并指定线程实例名
  • Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接 口中的run方法
  • Thread(Runnable target, String name)：创建新的Thread对象

实例

class ThreadDemo extends Thread {
   private Thread t;
   private String threadName;
   
   ThreadDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // 让线程睡眠一会
            Thread.sleep(50);
         }
      }catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}
 
public class TestThread {
 
   public static void main(String args[]) {
      ThreadDemo T1 = new ThreadDemo( "Thread-1");
      T1.start();
      
      ThreadDemo T2 = new ThreadDemo( "Thread-2");
      T2.start();
   }   
}

编译以上程序运行结果如下：

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

Thread 方法

下表列出了Thread类的一些重要方法：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dTJOYeoz-1636934095373)(D:\tongbu\我的坚果云\java\多线程知识_md_files\1_20211108143128.PNG?v=1&type=image&token=V1:HQvGXtamGeNvrM1A7icGTEF5_rs-imNkb54liB6Sfis)]

上述方法是被 Thread 对象调用的，下面表格的方法是 Thread 类的静态方法。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yDlJpmOo-1636934095377)(%E5%A4%9A%E7%BA%BF%E7%A8%8B%E7%9F%A5%E8%AF%86_md_files/2_20211108143147.PNG?v=1&type=image&token=V1:kzNQ3aWnYI8CII4Bx9W9dAJG7elgVwcjzkP0jxnUxvY)]

实例

windows 文件：

class windows extends Thread{
    private static int ticket = 100; //票
    @Override
    public void run() {

        while(true){
            if(ticket > 0){
                System.out.println(getName()+"卖票，票号为：" + ticket);
                ticket--;
            }else{
                break;
            }
        }

    }
}

WindowsTest 文件：

/**
 * 例子：创建三个售票窗口，总票数为100张
 * 线程安全问题，待解决
 * @author Token
 * @create 2021-11-13 21:18
 */
public class WindowsTest  extends Thread{
    public static void main(String[] args) {
        windows w1 = new windows();
        windows w2 = new windows();
        windows w3 = new windows();

        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");

        w1.start();
        w2.start();
        w3.start();
    }

}

执行结果：

image-20211113214334653

但是此方法中存在卖重复票的问题！！！

通过Runnable 接口重写卖票窗口程序：

package com.exer;

/**
 * 线程安全问题，待解决
 * @author Token
 * @create 2021-11-13 22:08
 */
public class windowsTest2 {
    public static void main(String[] args) {
        Runnable m1 = new MyThread();

        Thread t1 = new Thread(m1);
        Thread t2 = new Thread(m1);
        Thread t3 = new Thread(m1);

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

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

    }
}

class MyThread 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;
            }

        }
    }
}

３.通过 Callable 和 Future 创建线程

    1. 创建 Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值。
    1. 创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。
    1. 使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。
    1. 调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。

实例

public class CallableThreadTest implements Callable<Integer> {
    public static void main(String[] args)  
    {  
        CallableThreadTest ctt = new CallableThreadTest();  
        FutureTask<Integer> ft = new FutureTask<>(ctt);  
        for(int i = 0;i < 100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);  
            if(i==20)  
            {  
                new Thread(ft,"有返回值的线程").start();  
            }  
        }  
        try  
        {  
            System.out.println("子线程的返回值："+ft.get());  
        } catch (InterruptedException e)  
        {  
            e.printStackTrace();  
        } catch (ExecutionException e)  
        {  
            e.printStackTrace();  
        }  
  
    }
    @Override  
    public Integer call() throws Exception  
    {  
        int i = 0;  
        for(;i<100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" "+i);  
        }  
        return i;  
    }  
}

创建线程的三种方式的对比

  1. 采用实现 Runnable、Callable 接口的方式创建多线程时，线程类只是实现了 Runnable 接口或 Callable 接口，还可以继承其他类。

开发中：优先选择，实现Ｒunnable接口的方式

原因：1. 实现的方式没有类单继承的局限性

​ 2. 实现的方式更加适合来处理多个线程共享数据的情况

联系：public class Thread implement Runnable

相同点：两种方式都需要重写run()，将线程要执行的逻辑声明再run()中

  1. 使用继承 Thread 类的方式创建多线程时，编写简单，如果需要访问当前线程，则无需使用 Thread.currentThread() 方法，直接使用 this 即可获得当前线程。

线程的同步问题

  1. 问题：上述卖票过程中，出现了重票、错票问–>出现了线程的安全问题

  2. 出现的原因：当每个线程操作车票的过程中，尚未操作完成时，其他线程就进来了，也操作车票

  3. 如何解决：当一个线程 a 操作ticket的时候，其他线程不能参与进来，直到线程 a 操作完成ticket时，其他线程才开始操作ticket。这种情况即使线程 a 出现了阻塞，请其他线程也只能等待

  4. 再java中，我们使用同步机制，来解决线程的安全问题

    • 方式一：同步代码块

      synchronized(同步监视器){

	//需要被同步的代码

}

      说明：1. 操作同步代码块（共享数据）的代码，就是需要被同步的代码 -->不能包含代码多了，也不能包含代码 少了

      ​ 2.共享数据：多个线程共同操作的代码，比如：ticket就是共享数据

      ​ 3.同步监视器：俗称锁，任何一个类的对象，都可以充当锁，要求多个线程用同一把锁

      补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器

      ​ 在继承Thread类创建多线程的方式中，慎用this充当同步监视器。我们可以考虑使用当前类来充当同步监 视器。

    • 方式二：同步方法的方式

      class MyThread1 implements Runnable{
    private  int ticket = 100;//票

    @Override
    public void run () {
            while (true) {

                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                show();
            }

    }
	//同步方法的方式解决
    public synchronized void show(){//同步监视器为this
        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + "卖票。票号：" + ticket);
            ticket--;
        }
    }
}

      使用线程安全的方式解决单例模式中的懒汉式：

      class Bank{

    private Bank(){ }

    private static Bank instance = null;

    public static Bank getInstance() {
        //方式一：这种方式效率比较差
//        synchronized (Bank.class) {
//            if (instance == null) {
//                instance = new Bank();
//            }
//            return instance;
//        }
        //方式二：当instance不为空时，直接取走就行，不必进行等待
        if(instance == null){
            synchronized (Bank.class) {
                if (instance == null) {
                    instance = new Bank();
                }
            }
        }
        return instance;
    }
}

    1. 同步的方式，解决了线程的安全问题，但是操作代码块的时候，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低

      案例：

      class MyThread implements Runnable{
    private  int ticket = 100;//票
    Object obj = new Object();//锁

        @Override
        public void run () {
        synchronized (this){//此时的this代表的就是唯一的MyThread 对象  synchronized (obj) {	加上锁
            while (true) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "卖票。票号：" + ticket);
                    ticket--;
                } else {
                    break;
                }

            }
        }
    }
}

      注意点：再继承Thread方式中，加锁时锁对象不能使用this,因为此时的 this 指代 t1,t2,t3三个对象

      synchronized(windows2.class){}//用类来指代对象

      方式三：使用Lock锁 -->JDK5.0新增

      1. 实例化ReentrantLock (locks接口的实现类)
      2. 进行上锁：调用锁定方法：lock()
      3. 调用解锁方法：unlock()
      package com.exer.java1;

import java.util.concurrent.locks.ReentrantLock;

/**
 * 方式三：使用Lock锁 -->JDK5.0新增
 * @author Token
 * @create 2021-11-14 21:44
 */
class windows implements Runnable{
    private int tickte = 100; //车票
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){

            //2.进行上锁：调用锁定方法：lock()
            lock.lock();
            try{
                if(tickte > 0){

                    //为了让问题出现的更加明显，让线程休眠100毫秒
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName()+"卖票，票号：" + tickte);
                    tickte--;
                }else {
                    break;
                }
            }finally {
                //3.调用解锁方法：unlock()
                lock.unlock();
            }
            }

    }
}

public class LockTest {
    public static void main(String[] args) {
        windows w = new windows();

        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();
    }

}

面试题：synchronized 与 Lock的异同？

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

不同：

  • synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器

  • Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）

使用的优先顺序：

  • Lock —> 同步代码块（已经进入了方法体，分配了相应资源 ) —> 同步方法（在方法体之外)

练习：

银行有一个账户。 有两个储户分别向同一个账户存3000元，每次存1000，存3次。每次存完打 印账户余额。 问题：该程序是否有安全问题，如果有，如何解决？


//账户类
class Accout{
    private double balance;//银行账户，存储金额

    public Accout(double balance) {
        this.balance = balance;
    }

    /**
     * 添加synchronized关键字，使得线程变成安全的
     * @param amt 存取金额
     */
    public synchronized void deposit(double amt){
        if (amt >0){
            balance +=amt;

            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName()+":存钱成功，余额："+ balance);
        }
    }

}


//储户
class Customer extends Thread{
    private Accout acc;

    public Customer(Accout acc) {
        this.acc = acc;
    }

    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            acc.deposit(1000);
        }

    }
}


public class AccoutTest {
    public static void main(String[] args) {
        Accout a = new Accout(0);//两个储户

        Customer c1 = new Customer(a);
        Customer c2 = new Customer(a);

        c1.setName("甲");
        c2.setName("乙");

        c1.start();
        c2.start();
    }
}

线程的几个主要概念

在多线程编程时，你需要了解以下几个概念：

  • 线程同步
  • 线程间通信
  • 线程死锁
  • 线程控制：挂起、停止和恢复

多线程的使用

有效利用多线程的关键是理解程序是并发执行而不是串行执行的。例如：程序中有两个子系统需要并发执行，这时候就需要利用多线程编程。

通过对多线程的使用，可以编写出非常高效的程序。不过请注意，如果你创建太多的线程，程序执行的效率实际上是降低了，而不是提升了。

请记住，上下文的切换开销也很重要，如果你创建了太多的线程，CPU 花费在上下文的切换的时间将多于执行程序的时间！

魏皇子
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
Java面试题，即继承Thread重写run方法又实现了Runnable接口重写run方法，谁会执行？
qq_60479747的博客
08-17 424
原因：Thread匿名子类的构造器不需要target，当他没有重写run（）方法时，他会去找父类的run（）方法，他才会用到target变量，调用target.run（）传入的Runnable target形参才会起作用但是Thread子类重写了run（）方法，就不需要target变量了，传入Runnable target形参也就不起作用了，所以就会执行Thread匿名子类的构造器。//Java面试题，即继承Thread重写run方法又实现了Runnable接口重写run方法，谁会执行？...
Java 多进程编程
weixin_47230102的博客
05-23 1763
Java 多线程编程1. 进程是什么2. 进程和线程是啥关系?3. 进程和线程的区别 1. 进程是什么 进程(process) => 任务(task) ~ 双击 .exe 文件的时候, 操作系统就会读取这个可执行文件中的代码和数据, 放到内存中, 并且创建出一个进程来执行里面的代码 一个操作系统, 工作的时候里面本来就有很多的进程 这些进程各自在做各自的事情, 互相不干扰 进程的重要特点: 独立性 某个进程出现问题的时候, 只是当前进程崩溃了, 不会干扰到其他的进程 例如: 编译运行java程序
java 线程实现_用JAVA实现多线程
weixin_27956639的博客
02-19 98
用 JAVA 实现多线程 马 　铭 (吉林师范学院) 摘 　要 　多线程是现代操作系统中出现的概念。Java 虚拟机支持同时执行多个线 程。本文阐述了多线程的概念以及怎样使用Java 语言的多线程特性。 关键词 　多线程 ; 优先级 ; 线程同步 Windows95 和 Windows NT 操作系统支持多任务调度和处理 , 由此提出了多任务空间。 程序员可控制应用程序中每一个片段的运行 , 从而...
编写一个java程序实现多线程_1. 写出用Java编写多线程程序的两种常用方法
weixin_39761573的博客
02-25 888
展开全部1、继承Thread，然后生成对象2、用类A实现runable接口，然后用你实现runnable的类A，生成Thread对象 Thread(A对象)；API 上说62616964757a686964616fe78988e69d8331333361303666明如下：创建新执行线程有两种方法。一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的run 方法。接下来可以...
Java多线程编程技术
03-26
《Java多线程编程核心技术》建议猿友们读两遍，因为其写得没有那么抽象，第一遍有些概念不是很理解，可以先跳过并记录起来，第一遍阅读的目的主要是了解整个架构。第二遍再慢慢品味，并贯穿全部是指点来思考，并将...
Java多线程编程
05-02
包括java的Thread类，同步块(synchronized)，可重入锁，Object方法以及对象监视器等内容。
JAVA多线程编程技术PDF
08-28
JAVA多线程编程技术PDF，是最经典的那个版本，多线程的所有知识点完爆读者
Java多线程编程实战指南(核心篇)
07-17
Java多线程编程实战指南(核心篇) 高清pdf带目录 随着现代处理器的生产工艺从提升处理器主频频率转向多核化，即在一块芯片上集成多个处理器内核（Core），多核处理器（Multicore Processor）离我们越来越近了――如今...
java 线程怎么写_如何使用Java编写多线程程序
weixin_35696012的博客
03-07 116
二、准备知识在分析这个例子之前，然我们先看看关于线程的几个概念，上锁，信号量，和java所提供的API。上锁对于大多数的程序而言，他们都需要线程之间相互的通讯来完成整个线程的生命周期，二实现线程之间同步的最简单的办法就是上锁。为了防止相互关联的两个线程之间错误地访问共享资源，线程需要在访问资源的时候上锁和解锁，对于锁而言，有读锁，写锁和读写锁等不同的同步策略。在java中，所有的对象都有锁；线程只...
16：00面试，16：06就出来了，问的问题有点变态。。。
qq_48811377的博客
04-30 6109
整份文档一共有将近 200 页，全部为大家展示出来肯定是不太现实的，为了不影响大家的阅读体验就只展示了部分内容，还望大家海涵，希望能帮助到您面试前的复习且找到一个好的工作，也节省大家在网上搜索资料的时间来学习！
面试经典150题——最长公共前缀
weixin_42075274的博客
04-28 569
面试经典150题 最长公共前缀 遍历 分治 字典树
【校招VIP】985 211求职策略
shuize123的博客
04-28 1027
校招在同个层次，大厂对学生的要求是一样的，大家也没有工作背景，所以考察东西都是基本上是一致的，考点非常的清楚，所以不管是算法还是专业课，还是语言考点，都能够快速的把它准备好。而很多其他的所谓的卖课大V也好，或者培训班也好，最主要的问题就是项目部分，如果不满足重复度低、亮点多、真实度高的这个特点的话，你的简历就跟几万份的其他的同学的简历是一样的。所以这个同学的问题，可能是他的算法没有准备好，也可能是他的简历项目的重复度非常高，或者有些明显的虚假问题，又或者是明显的表达问题，所以面试官不给面试机会。
嵌入式一些面试题
博客
04-28 647
部分面试题
Android性能优化面试题汇总
xiangzhihong8的专栏
04-29 88
Android的性能优化涉及多个方面，如启动优化、稳定性优化、内存优化、网络优化、电量优化、安全优化等方面。
链表经典面试题上
A13569039691的博客
05-02 1102
链表经典面试题详解
面试 Java 基础八股文十问十答第二十八期
最新发布
qq_67358181的博客
05-04 879
相信看了本文后，对你的面试是有一定帮助的！关注专栏后就能收到持续更新！⭐。
java 多线程编程pdf
12-16
Java多线程编程PDF是一本介绍Java多线程编程的PDF文档，其中包含了Java多线程编程的基本概念、原理、技术和实践经验。该PDF文档可以帮助读者快速了解Java多线程编程的相关知识，并提供实用的编程示例和案例分析，有...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值