Java学习笔记——多线程

最新推荐文章于 2021-10-27 14:18:47 发布
最新推荐文章于 2021-10-27 14:18:47 发布
阅读量252 收藏 1
点赞数 1
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shendezhuti/article/details/97914440
版权

简介

Java给多线程编程提供了内置的支持，一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。本节主要讲解 Java 多线程的一些概念以及其实现。

知识点

  • 多线程的实现
  • 线程变量
  • 线程同步
  • Lock 与 Unlock
  • 死锁
  • 线程生命周期
  • ArrayBlockingQueue
  • 生产者消费者模式
  • 线程池

什么是线程

线程：程序执行流的最小单元。它是进程内一个相对独立的、可调度的执行单元，是系统独立调度和分派 CPU 的基本单位。

如同大自然中的万物，线程也有“生老病死”的过程，下图表示了一个线程从创建到消亡的过程，以及过程中的状态。

线程生命周期

结合线程的生命周期来看看多线程的定义：

多线程：从软件或者硬件上实现多个线程并发执行的技术。在单个程序中同时运行多个线程完成不同的工作。

在 Java 中，垃圾回收机制就是通过一个线程在后台实现的，这样做的好处在于：开发者通常不需要为内存管理投入太多的精力。反映到我们现实生活中，在浏览网页时，浏览器能够同时下载多张图片；实验楼的服务器能够容纳多个用户同时进行在线实验，这些都是多线程带来的好处。

从专业的角度来看，多线程编程是为了最大限度地利用 CPU 资源——当处理某个线程不需要占用 CPU 而只需要利用 IO 资源时，允许其他的那些需要 CPU 资源的线程有机会利用 CPU。这或许就是多线程编程的最终目的。当然，你也可以进一步了解。

对于多线程和线程之间的关系，你可以这样理解：一个使用了多线程技术的程序，包含了两条或两条以上并发运行的线程（Thread）。

多线程实现

Java 中的Thread类就是专门用来创建线程和操作线程的类。

创建线程

创建线程的方法：

  1. 继承 Thread 类并重写它的run()方法，然后用这个子类来创建对象并调用start()方法。
  2. 定义一个类并实现 Runnable 接口，实现run()方法。

总的来说就是线程通过 start()方法启动而不是 run()方法，run()方法的内容为我们要实现的业务逻辑。

编程实例

在/home/project/目录下新建一个类CreateThread。

代码片段如下：

public class CreateThread {

    public static void main(String[] args) {
        Thread1 thread1 = new Thread1();
        //声明一个Thread1对象，这个Thread1类继承自Thread类的

        Thread thread2 = new Thread(new Thread2());
        //传递一个匿名对象作为参数

        thread1.start();
        thread2.start();
        //启动线程
    }
}

class Thread1 extends Thread {
    @Override
    public void run() {
        //在run()方法中放入线程要完成的工作

        //这里我们把两个线程各自的工作设置为打印100次信息
        for (int i = 0; i < 100; ++i) {
            System.out.println("Hello! This is " + i);
        }

        //在这个循环结束后，线程便会自动结束
    }
}

class Thread2 implements Runnable {
    //与Thread1不同，如果当一个线程已经继承了另一个类时，就建议你通过实现Runnable接口来构造

    @Override
    public void run() {
        for (int i = 0; i < 100; ++i) {
            System.out.println("Thanks. There is " + i);
        }
    }
}

编译运行

$ javac CreateThread.java
$ java CreateThread
Hello! This is 0
Hello! This is 1
Hello! This is 2
Thanks. There is 0
Thanks. There is 1
Hello! This is 3
Hello! This is 4
Thanks. There is 2
........

你在控制台就可以看到两个线程近似交替地在输出信息。受到系统调度的影响，两个线程输出信息的先后顺序可能不同。

 

线程变量

ThreadLocal，即线程变量，是一个以 ThreadLocal 对象为键、任意对象为值的存储结构。这个结构被附带在线程上，也就是说一个线程可以根据一个 ThreadLocal 对象查询到绑定在这个线程上的一个值。
可以通过 set(T)方法来设置一个值，在当前线程下再通过 get()方法获取到原先设置的值。

编程实例

在/home/project/目录下新建一个源代码文件ThreadLocalDemo.java

public class ThreadLocalDemo {

    public static void main(String[] args) {
        ThreadDemo threadDemo = new ThreadDemo();
        //启动2个线程
        new Thread(threadDemo).start();
        new Thread(threadDemo).start();

    }
}

class ThreadDemo implements Runnable {
    //使用ThreadLocal提供的静态方法创建一个线程变量 并且初始化值为0
    private static ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 0);

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            //get方法获取线程变量值
            Integer integer = threadLocal.get();
            integer += 1;
            //set方法设置线程变量值
            threadLocal.set(integer);
            System.out.println(integer);
        }
    }
}

编译运行：

$ javac ThreadLocalDemo.java
$ java ThreadLocalDemo
1
1
2
2
3
3
4
4
5
5
6
6
7
7
8
8
9
10
9
10

通过控制台的结果可以看到，两个线程之间的变量互不干涉。

线程共享变量

如果我们去掉了 ThreadLocal，其他的流程都不改变，已经使用 2 个线程自增变量会如何呢？

修改ThreadLocalDemo.java

public class ThreadLocalDemo {

    public static void main(String[] args) {
        ThreadDemo threadDemo = new ThreadDemo();
        new Thread(threadDemo).start();
        new Thread(threadDemo).start();

    }
}

class ThreadDemo implements Runnable {
    private Integer integer = 0;

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            integer++;
            System.out.println(integer);
        }
    }
}

编译运行：

$ javac ThreadLocalDemo.java
$ java ThreadLocalDemo

1
3
4
5
6
7
8
9
10
11
2
12
13
14
15
16
17
18
19
20

在没有加入 ThreadLocal 的情况下，发现 integer 变量的值增加到了 20，那是因为这个时候两个线程都是使用同一对象threadDemo的变量，这个时候的 integer 就变成了线程共享变量，如果同学们多运行几次，还有可能出现最后结果是 18 19 的情况，那是因为如果不做任何处理，线程共享变量都不是线程安全的，也就是说在多线程的情况下，共享变量有可能会出错。

线程同步

当多个线程操作同一个对象时，就会出现线程安全问题，被多个线程同时操作的对象数据可能会发生错误。线程同步可以保证在同一个时刻该对象只被一个线程访问。

Synchronized

关键字 synchronized 可以修饰方法或者以同步块的形式来进行使用，它确保多个线程在同一个时刻，只能有一个线程处于方法或者同步块中，保证了线程对变量访问的可见性和排他性。它有三种使用方法：

  • 对普通方式使用，将会锁住当前实例对象
  • 对静态方法使用，将会锁住当前类的 Class 对象
  • 对代码块使用，将会锁住代码块中的对象

使用示例

在下面的代码中，演示了三种加锁方式。

public class SynchronizedDemo {
    private static Object lock = new Object();

    public static void main(String[] args) {
        //同步代码块 锁住lock
        synchronized (lock) {
            //doSomething
        }
    }

    //静态同步方法  锁住当前类class对象
    public synchronized static void staticMethod(){

    }
    //普通同步方法  锁住当前实例对象
    public synchronized void memberMethod() {

    }
}

 

java.util.concurrent

java.util.concurrent 包是 java5 开始引入的并发类库，提供了多种在并发编程中的适用工具类。包括原子操作类，线程池，阻塞队列，Fork/Join 框架，并发集合，线程同步锁等。

Lock 与 Unlock

JUC 中的 ReentrantLock 是多线程编程中常用的加锁方式，ReentrantLock 加锁比 synchronized 加锁更加的灵活，提供了更加丰富的功能。

编程实战

在/home/project/目录下新建一个源代码文件LockDemo.java

import java.util.concurrent.locks.ReentrantLock;

public class LockDemo {
    private static ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            lock.lock();
            try {
                //需要同步的代码块
                System.out.println("线程1加锁");
            }finally {
//                一定要在finally中解锁，否则可能造成死锁
                lock.unlock();
                System.out.println("线程1解锁");
            }
        });
        thread1.start();
        Thread thread2 = new Thread(() -> {
            lock.lock();
            try {
                System.out.println("线程2加锁");
            }finally {
                lock.unlock();
                System.out.println("线程2解锁");
            }
        });
        thread2.start();
    }

}

编译运行：


$ javac LockDemo.java
$ java LockDemo
线程1加锁
线程1解锁
线程2加锁
线程2解锁

 

死锁

在多线程环境下，锁的使用非常频繁，但是它会带来一下问题，比如死锁。当死锁发生时，系统将会瘫痪。比如两个线程互相等待对方释放锁。

死锁示例

在/home/project/目录下新建一个源代码文件DeadLockDemo.java。

public class DeadLockDemo {
    private static Object lockA = new Object();
    private static Object lockB = new Object();

    public static void main(String[] args) {
        //这里使用lambda表达式创建了一个线程  
        //线程  1
        new Thread(() -> {
            synchronized (lockA) {
                try {
                    //线程休眠一段时间  确保另外一个线程可以获取到b锁
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("D");
                synchronized (lockB) {
                }
            }
        }).start();
        //线程 2
        new Thread(() -> {
            synchronized (lockB) {
                System.out.println("死锁...");
                synchronized (lockA) {
                }
            }
        }).start();
    }
}

编译运行：

$ javac DeadLockDemo.java
$ java DeadLockDemo
死锁...
D

在上面的编程实例中，线程 1 获取了 lockA 的锁后再去获取 lockB 的锁，而此时 lockB 已经被线程 2 获取，同时线程 2 也想获取 lockA，两个线程进这样僵持了下去，谁也不让，造成了死锁。在编程时，应该避免死锁的出现。

饥饿

饥饿是指一个可运行的进程尽管能继续执行，但被调度器无限期地忽视，而不能被调度执行的情况。

比如当前线程处于一个低优先级的情况下，操作系统每次都调用高优先级的线程运行，就会导致当前线程虽然可以运行，但是一直不能被运行的情况。

线程生命周期

线程的声明周期共有 6 种状态，分别是：新建New、运行（可运行）Runnable、阻塞Blocked、计时等待Timed Waiting、等待Waiting和终止Terminate。

当你声明一个线程对象时，线程处于新建状态，系统不会为它分配资源，它只是一个空的线程对象。

调用start()方法时，线程就成为了可运行状态，至于是否是运行状态，则要看系统的调度了。

调用了sleep()方法、调用wait()方法和 IO 阻塞时，线程处于等待、计时等待或阻塞状态。

当run()方法执行结束后，线程也就终止了。

我们通过一个例子来加深对于这些状态的理解。
在/home/project/目录下新建ThreadState类，用于自定义线程的状态。

主要的代码如下：

public class ThreadState implements Runnable {

    public synchronized void waitForAMoment() throws InterruptedException {

        wait(500);
        //使用wait()方法使当前线程等待500毫秒
        //或者等待其他线程调用notify()或notifyAll()方法来唤醒
    }

    public synchronized void waitForever() throws InterruptedException {

        wait();
        //不填入时间就意味着使当前线程永久等待，
        //只能等到其他线程调用notify()或notifyAll()方法才能唤醒
    }

    public synchronized void notifyNow() throws InterruptedException {

        notify();
        //使用notify()方法来唤醒那些因为调用了wait()方法而进入等待状态的线程
    }

    @Override
    public void run() {

        //这里用异常处理是为了防止可能的中断异常
        //如果任何线程中断了当前线程，则抛出该异常

        try {
            waitForAMoment();
            // 在新线程中运行waitMoment()方法

            waitForever();
            // 在新线程中运行waitForever()方法

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

然后再新建一个测试类ThreadTest，用于输出这些状态。

接下来会用到sleep()方法，下面给出了这个方法的使用方法。

sleep()，在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。填入的参数为休眠的时间（单位：毫秒）。

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException {
        ThreadState state = new ThreadState();
        //声明并实例化一个ThreadState对象

        Thread thread = new Thread(state);
        //利用这个名为state的ThreadState对象来创建Thread对象

        System.out.println("Create new thread: " + thread.getState());
        //使用getState()方法来获得线程的状态，并进行输出

        thread.start(); 
        //使用thread对象的start()方法来启动新的线程

        System.out.println("Start the thread: " + thread.getState());
        //输出线程的状态

        Thread.sleep(100); 
        //通过调用sleep()方法使当前这个线程休眠100毫秒，从而使新的线程运行waitForAMoment()方法

        System.out.println("Waiting for a moment (time): " + thread.getState());
        //输出线程的状态

        Thread.sleep(1000); 
        //使当前这个线程休眠1000毫秒，从而使新的线程运行waitForever()方法

        System.out.println("Waiting for a moment: " + thread.getState());
        //输出线程的状态

        state.notifyNow(); 
        // 调用state的notifyNow()方法

        System.out.println("Wake up the thread: " + thread.getState());
        //输出线程的状态

        Thread.sleep(1000); 
        //使当前线程休眠1000毫秒，使新线程结束

        System.out.println("Terminate the thread: " + thread.getState());
        //输出线程的状态
    }
}

检查一下代码，编译并运行

$ javac ThreadState.java ThreadTest.java
$ java ThreadTest
Create new thread: NEW
Start the thread: RUNNABLE
Waiting for a moment (time): TIMED_WAITING
Waiting for a moment: WAITING
Wake up the thread: BLOCKED
Terminate the thread: TERMINATED

 

练习题：顺序打印字母

在/home/project/目录下新建文件ThreadTest.java

你需要完成以下需求：

  1. 创建三个线程输出 A、B、C 三个字符。
  2. 要求 A、B、C 必须顺序输出，连续输出三次。

结果如下:

A
B
C
A
B
C
A
B
C

参考答案

注意：请务必先独立思考获得 PASS 之后再查看参考代码，直接拷贝代码收获不大

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadTest {
    private static ReentrantLock lock = new ReentrantLock();
    private static int count = 0;
    private static Condition condition = lock.newCondition();

    public static void main(String[] args) {
        Thread A = new Thread(() -> {
        //加锁 一次只有一个线程输出
            lock.lock();
            try {
                while (true) {
                //因为只循环3次 所以到9的时候就结束循环
                    if (count == 9) {
                        break;
                    }
                    //当余数为0 就输出A
                    if (count % 3 == 0) {
                        count++;
                        System.out.println("A");
                        //唤醒其他等待线程
                        condition.signalAll();
                    } else {
                        try {
                        //等待
                            condition.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            } finally {
                lock.unlock();
            }
        });
        Thread B = new Thread(() -> {
            lock.lock();
            try {
                while (true) {
                    if (count == 9) {
                        break;
                    }
                    if (count % 3 == 1) {
                        count++;
                        System.out.println("B");
                        condition.signalAll();
                    } else {
                        try {
                            condition.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            } finally {
                lock.unlock();
            }
        });
        Thread C = new Thread(() -> {
            lock.lock();
            try {
                while (true) {
                    if (count == 9) {
                        break;
                    }
                    if (count % 3 == 2) {
                        count++;
                        System.out.println("C");
                        condition.signalAll();
                    } else {
                        try {
                            condition.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            } finally {
                lock.unlock();
            }
        });

        A.start();
        B.start();
        C.start();

    }
}

ArrayBlockingQueue

ArrayBlockingQueue 是由数组支持的有界阻塞队列。位于java.util.concurrent包下。

首先看看其构造方法:

构造方法描述
public ArrayBlockingQueue(int capacity)构造大小为 capacity 的队列
public ArrayBlockingQueue(int capacity, boolean fair)指定队列大小，以及内部实现是公平锁还是非公平锁
public ArrayBlockingQueue(int capacity, boolean fair, Collection<? extends E> c)指定队列大小，以及锁实现，并且在初始化是加入集合 c

入队常用方法：

入队方法队列已满队列未满
add抛出异常返回 true
offer返回 false返回 true
put阻塞直到插入没有返回值

出队常用方法

出队方法队列为空队列不为空
remove抛出异常移出并返回队首
poll返回 null移出并返回队首
take阻塞直到返回移出并返回队首

生产者消费者模式

生产者消费者模式是多线程编程中非常重要的设计模式，生产者负责生产数据，消费者负责消费数据。生产者消费者模式中间通常还有一个缓冲区，用于存放生产者生产的数据，而消费者则从缓冲区中获取，这样可以降低生产者和消费者之间的耦合度。举个例子来说吧，比如有厂家，代理商，顾客，厂家就是生产者，顾客就是消费者，代理商就是缓冲区，顾客从代理商这里买东西，代理商负责从厂家处拿货，并且销售给顾客，顾客不用直接和厂家打交道，并且通过代理商，就可以直接获取商品，或者从代理商处知道货物不足，需要等待。

编程实例

在/home/project目录下新建一个源代码文件PCModel.java

import java.util.Random;
import java.util.concurrent.LinkedBlockingQueue;

public class PCModel {
    //阻塞队列
    private static LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>();

    public static void main(String[] args) {
        //生产者
        Thread provider = new Thread(() -> {
            Random random = new Random();
            for (int j = 0; j < 5; j++) {
                try {
                    int i = random.nextInt();
                    //注释直到插入数据
                    queue.put(i);
                    System.out.println("生产数据：" + i);
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        //消费者
        Thread consumer = new Thread(() -> {
            Integer data;
            for (int i = 0; i < 5; i++) {
                try {
                    //阻塞直到取出数据
                    data = queue.take();
                    System.out.println("消费数据：" + data);
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        //启动线程
        provider.start();
        consumer.start();
    }
}

 

 

 

练习题

在/home/project目录下新建一个源代码文件ProviderConsumerTest.java，你需要完成以下需求：

  1. 参照编程实例，启动多个生产者和消费者生成和消费数据

注意：不要直接使用上面的编程实例直接使用多个provider.start()或者consumer.start()，会抛出异常报错，应该重新实例化多个生产者和消费者，不能一个实例启动多次

 

 

 

线程池

线程池（英语：thread pool）：一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。

由于 Java 创建和销毁线程都会带来资源上的销毁，所以线程池可以帮助我们复用线程，减少资源消耗。

 

编程实战

 

Java 线程池可以通过 Executors 工具类创建，Executors 常用方法：

 

  • newFixedThreadPool(int nThreads):创建一个固定大小为 n 的线程池
  • newSingleThreadExecutor():创建只有一个线程的线程池
  • newCachedThreadPool():创建一个根据需要创建新线程的线程池

 

在/home/project/目录下新建源代码文件TheadPoolDemo.java

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolDemo {
    //使用Executors 创建一个固定大小为5的线程池
    private static ExecutorService executorService = Executors.newFixedThreadPool(5);

    public static void main(String[] args) {
//        提交任务
        executorService.submit(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.print(i + " ");
            }
        });
        //停止线程池 并不会立即关闭 ，而是在线程池中的任务执行完毕后才关闭
        executorService.shutdown();
    }
}

编译运行：

$ javac ThreadPoolDemo.java
$ java ThreadPoolDemo
0 1 2 3 4 5 6 7 8 9

除了使用 Executors 工具类帮助我们创建之外，也可以直接创建线程池。

在/home/project/目录下新建源代码文件ThreadPoolDemo2.java

import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPoolDemo2 {
    private static ExecutorService executorService = new ThreadPoolExecutor(
            5, //核心线程数为5
            10,//最大线程数为10
            0L, TimeUnit.MILLISECONDS,//非核心线程存活时间
            new LinkedBlockingQueue<>());//任务队列 

    public static void main(String[] args) {
        //提交任务
        executorService.submit(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.print(i + " ");
            }
        });
        //关闭线程池
        executorService.shutdown();
    }
}

编译运行：

$ javac ThreadPoolDemo2.java
$ java ThreadPoolDemo2
0 1 2 3 4 5 6 7 8 9

总结

本节主要内容是对 Java 多线程进行讲解，主要包含以下知识点：

  • 多线程的实现
  • 线程变量
  • 线程同步
  • Lock 与 Unlock
  • 死锁
  • 线程生命周期
  • ArrayBlockingQueue
  • 生产者消费者模式
  • 线程池

请大家务必手动完成代码并运行对比结果，这样才能更好的理解并掌握 Java 网络编程，如果还想深入学习多线程编程，可以继续学习 Java 实现简单的支付平台业务流程课程。

 

 

 

 

 

 

shendezhuti
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#关于Lock(object)使用笔记
NA_navy的博客
05-14 1446
个人笔记以及吐槽 在写多线程代码时,经常遇见并发问题. 如何有效的控制单一线程进入操作,后续等待是个问题. 鄙人小白一枚.同时也是懒癌晚期.随使用了Lock来锁定. 个人总结 lock可以分为 2个形态 1.公共列队 2.独立对象内部列队 公共列队 所谓公共列队,就是无论多少个线程进入该代码段访问时,全部都要乖乖排队. 公共列队的实现是通过 静态字段 static 实现的.例如 private static object 列队锁 = new object(); public void X() { lock
Java中的多线程
每天进步一点
03-18 427
转自： http://blog.csdn.net/axman/article/details/420890； http://www.cnblogs.com/DreamSea/archive/2012/01/16/sleepandwaitdifferent.html； http://blog.csdn.net/zyplus/article/details/6672775 一 线程对象和线程 线
线程的生命周期
qq_40807366的博客
12-17 150
新建： new 关键字创建了一个线程之后，该线程就处于新建状态 JVM为线程分配内存，初始化成员变量 就绪： 当线程对象调用了start() 方法之后，该线程处于就绪状态 JVM为线程创建方法栈帧和程序计数器，等待线程调用器调用 运行： 就绪状态的线程获得CPU资源，开始运行run() 方法，该线程进入运行状态 阻塞： 当发生如下情况时，线程将会进入阻塞状态 线程调用sleep() ...
进程锁技巧
yw1688的专栏
03-27 762
在使用进程锁时，很多时候我们都是用lock(new Object())或者定义一个static的object然后lock这个对象，这样子会造成全局锁。但是这样会造成一些意想不到的麻烦。有些时候，事件并发，每人操作一条记录，当这个人操作这个记录的时候，不让别人操作，但是不影响别人操作另外的记录，这时候我们可以这样子做： using System.Collections.Generic; name
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
Java学习笔记——良葛格
06-12
"Java学习笔记——良葛格"是一份专为初学者设计的教程资料，由良葛格精心编写，旨在帮助读者掌握JDK5.0版本的Java基础知识。JDK（Java Development Kit）是Java开发的核心工具集，包含了编译器、调试器和运行环境等...
JAVA学习笔记————————
04-25
在深入探讨JAVA学习笔记之前，我们首先理解一下JAVA这一编程语言的重要性。JAVA，由Sun Microsystems公司（现已被Oracle收购）于1995年推出，是一种面向对象的、跨平台的编程语言，以其“一次编写，到处运行”的特性...
个人学习的java笔记——思维导图
01-25
这份"个人学习的java笔记——思维导图"涵盖了上述诸多Java编程的核心知识点，通过思维导图的方式，使得学习者可以更直观地理解和记忆这些复杂的概念，对提升Java学习效果大有裨益。无论你是初学者还是有经验的开发者...
学习笔记(13)---Lock简单使用
qq_44484973的博客
06-18 309
上一篇中，把线程声明在内部就不会有丢失现象，还可以用lock锁，锁住线程，这样也能不会出现数据丢失。 声明锁 private static readonly object LockThread = new object(); private 避免外部锁定，static 唯一的---Lock(this)，readonly 避免引用被改动，object 必须引用类lock要尽量减小作用的...
Java学习笔记——网络编程
黄小鑫的博客
07-31 200
之前学习了计算机网络的课程 但是没有结合java练习过。这篇文章打算记录一些java网络编程知识点以及找一个小project练练手。 Socket 简介 网络上的两个程序通过一个双向的通信连接实现数据的交换，这个连接的一端称为一个 socket。 建立网络通信连接至少要一对端口号(socket)。socket 本质是编程接口(API)，对 TCP/IP 的封装，TCP/IP 也要提供可供程序员...
Java 多线程编程5---线程操作案例：生产者和消费者
小蓝的博客
07-16 401
在线程操作中有一个经典的案例，即生产者和消费者问题。生产者不断生产，消费者不断取走生产者生产的产品。即生产者生产出的产品放到一个区域中，消费者从该区域中取走产品.如下图所示。 在上面的方式中，如果使用多线程运行，由于多线程运行的不确定性，会存在以下问题: 假设生产者线程刚向数据存储空间中加入该信息的名称，还没有加入信息的内容，程序就切换到了消费者线程，消费者线程把信息的名称和上一个信息的...
二十五、JAVA多线程（四、生产者和消费者问题）
bigdodo的博客
06-01 2133
一、生产者和消费者问题分析线程通信:不同的线程执行不同的任务,如果这些任务有某种关系,线程之间必须能够通信,协调完成工作。经典的生产者和消费者案例(Producer/Consumer):     分析案例:              1):生产者和消费者应该操作共享的资源(实现方式来做)。              2):使用一个或多个线程来表示生产者(Producer。             ...
笔试题11:编写一个生产者与消费者的多线程例子(源码)
maxiaokun55的专栏
08-06 1896
生产者与消费者模式，是一道非常经典的设计模式，所涉及到的是多线程协调工作的问题。在Java中，一般是通过wait()和notify()方法进行解决。 下面附上关于这种设计模式的源码： [java] view plaincopy //仓库类   public class Store {              private fina
多线程之生产者/消费者模式（值操作）
食鱼酱的博客
01-07 3706
1、一个生产者，一个消费者（值操作） 本小节是典型的单个生产者，单个消费者，生产对象为值的Demo 如下，我们假设ValueObject .value为生产的值，当value的值为 “”（空串）时，我们认为生产出来的对象已被消费，当value的值不为空串时，我们认为生产出来的对象未被消费。 public class ValueObject { public static Stri
线程的使用：继承Thread类和实现Runnable接口
weixin_50659410的博客
10-27 540
线程的基本使用 线程使用应用案例——多线程执行 请编写一个程序，创建两个线程，一个线程每隔一秒输出“HelloWorld!",输出十次。退出，另一个线程每隔一秒输出一次”hi“输出五次，退出。 方法1，继承Thread类 package com.yuecheng.hspedu.Runnable00; public class Runnable04 { public static void main(String[] args) { a1 a1 = new a1();
synchronized 中的if与while，notify与notifyAll
kingdelee的专栏
07-04 972
/* 生产者，消费者。 多生产者，多消费者的问题。 if判断标记，只有一次，会导致不该运行的线程运行了。出现了数据错误的情况。 while判断标记，解决了线程获取执行权后，是否要运行！ notify:只能唤醒一个线程，如果本方唤醒了本方，没有意义。而且while判断标记+notify会导致死锁。 notifyAll解决了本方线程一定会唤醒对方线程的问题。 */ class Resourc
创建线程的两种方式：继承Thread类和实现Runnable接口
weixin_30888027的博客
05-14 558
第一种方式：继承Thread类 步骤：1、定义类继承Thread 2、覆写Threa类的run方法。 自定义代码放在run方法中，让线程运行 3、调用线程的star方法， 该线程有两个作用：启动线程，调用run方法。 代码示例： 1 class Test extends Thread 2 { 3 //private String n...
【Java】 字符串处理----《实验楼》练习题
徐海洋
12-29 678
在/home/project/目录下新建StringUtil.java，你需要实现以下需求： 1.从控制台输入一行字符串 2.去除字符串中的所有空格 3.打印去除空格后的字符串 示例： 输入： shi ya n lou 输出： shiyanlou 提示：java.util.Scanner可以获取控制台输入。 Scanner in =new Scanner(System.in);...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值