Java多线程

已于 2022-11-25 19:35:30 修改
阅读量305 收藏
点赞数
分类专栏： JAVA多线程 Java基础 文章标签： java
于 2022-11-22 14:51:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49076273/article/details/127931935
版权

文章目录

一、对象及变量的并发访问（理论）

  1. 脏读(dirty read),发生脏读的原因是在读取实例变量时，此值已经被其他线程改过了。
    即不同线程在读取和写同时操作，“争抢”实例变量导致的结果。此时变量至少为2个。
    可以使用synchronized关键字实现同步来解决，即获得锁的线程执行完，释放锁后，其他线程才能执行。也可使用读写锁。
  2. synchronized拥有重入锁，指自己可以再次获取自己的内部锁。
    即拿到一个对象锁之后，在未释放之前可以继续获取这个对象锁。
    也就是说访问一个synchronized修饰的方法后，可以访问该对象内的全部synchronized修饰的方法。
    this关键字指当前对象，将this作为锁时，当前对象的所有synchronized修饰的方法或this作为锁的代码块同一时间都由一个线程同步访问。
  3. holdsLock()是当currentThread在指定的对象上保持锁定时，才返回true。
  4. synchronized方法将当前对象作为锁，synchronized代码块将任意对象作为锁。
    即前者对象中被修饰的全部方法都是同步的，而后面可灵活使用同步，可以选择单个方法或多个方法，并且可以选择方法中的部分或者整体。
  5. synchronize(string)同步块与string联合使用，注意jvm的常量池带来的意外。即用string作为锁若在常量池中存在，2个线程的string相同，则会导致原本是异步执行的两个线程变成同步执行。
    synchronized代码块不使用string作为锁对象。
  6. java线程死锁，因为不同的线程都在等待根本不可能释放的锁，从而导致所有的任务都无法继续完成。在多线程技术中，“死锁”是必须避免的，因为这会造成线程“假死”。
    即线程之间相互等待对方的锁。
  7. 内置类和静态内置类，内置类是在类实例化之后，调用并new一个实例中的内置类。
    而静态修饰的内置类，则可以直接new一个静态内置类。
    使用static修饰内置类，可以将new出来的内置类实例作为唯一锁，从而使代码块和内置类中用synchronized关键字修饰的方法同步。
  8. 锁对象改变，会使同步执行变为异步执行。
    锁对象不变，而锁对象属性的改变，也可以同步执行。
  9. volatile关键字
    可见性，b线程可以马上看到a线程更改的数据。
    原子性，64位系统，原子性取决于具体的实现。
    禁止代码重排序。
    可见性
    解决死循环，通过另一个线程来改变循环的条件，使其结束循环。
    变量存在于公共堆栈及线程的私有堆栈中，线程运行后，一直在线程的私有堆栈中取变量的值。此时更改变量的值，是更改在公共堆栈的变量的值。
    此时使用volatile关键字修饰锁变量，强制让当前线程访问公共堆栈中的变量，而不在线程的私有堆栈中取值。
    synchronized关键字，可以使多个线程访问同一个资源具有同步性，而且具有使线程工作内存中的私有变量与公共内存中的变量同步的特性，即可见性。

原子性
即volatile和synchronized关键字都可以实现可见性和原子性。
volatile使用的主要场合是在多个线程中可以感知实例变量被更改了。从而实现了增加可见性和原子性。
atomic原子类实现原子性，可以在没有锁的情况下实现线程安全。
atomic原子类的方法是原子的，但是方法中atomic原子类多次调用方法，此时方法与方法之间是非原子的。只能用synchronized关键字修饰来实现方法与方法之间的原子性。

禁止代码重排序
java程序运行时，JIT(Just-In-Time Compiler)即时编译器可以动态地改变程序代码运行的顺序。
重排序是将轻耗时的代码执行完后，释放cpu资源给其他重耗时的代码，从而实现更高的程序运行效率。
重排序发生在没有依赖关系时，代码之间有关系则代码不会重排序。

使用volatile关键字修饰，可以禁止代码重排序。
但是仅volatile关键字修饰的变量禁止重排序，且以该变量为中心将代码分割成2部分，这两部分可以分别独立地进行重排序。与synchronized相同。
总结
volatile关键字和synchronized关键字都具有增加可见性、原子性和禁止重排序。
使用场景
volatile，当想实现一个变量的值被更改时，让其他线程能取到最新的值时，就要对变量使用volatile。
synchronized，当多个线程对同一个对象中的同一个实例变量进行操作时，为了避免出现非线程安全问题，就要使用synchronized。

二、Java多线程通信（实践）

1.多生产与多消费（操作栈）

  1. 创建一个signal.entity包，创建MyStack类

    package signal.entity;

import java.util.ArrayList;
import java.util.List;

public class MyStack
{
	//生成list对象
    private List list = new ArrayList<>();
    synchronized public void push()
    {
        try
        {
            while(list.size()==1)
            {
                this.wait();
            }
            list.add("anyString="+Math.random());
            this.notifyAll();
            System.out.println("push="+list.size());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
	//弹出
    synchronized public String pop()
    {
        String returnValue = "";
        try
        {
            while(list.size()==0)
            {
                System.out.println("pop操作中的："+Thread.currentThread().getName()+"线程wait状态");
                this.wait();
            }
            returnValue =""+list.get(0);
            list.remove(0);
            this.notifyAll();
            System.out.println("pop="+list.size());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return returnValue;
    }
}

    MyStack类，主要作用是生成控制这个操作栈的推入和弹出方法。
    在方法内部使用While进行判断，因为存在多个消费者，如果使用if，则判断过后多个消费者就会执行remove，此时会报错，而使用While可以使没有拿到锁的对象继续wait。
    以及使用notifyAll()，使用多消费者或多生产者时，防止notify()唤醒同类型线程，导致线程假死。

  2. 创建一个signal.service包，创建P类

    package signal.service;

import signal.entity.MyStack;

public class P {
    private MyStack myStack;
    public P(MyStack myStack)
    {
        super();
        this.myStack = myStack;
    }
    public void pushService()
    {
        myStack.push();
    }
}

    即在生产者类P中内聚一个MyStack对象，由构造方法给该MyStack对象赋值，调用MyStack的push方法。

  3. 创建一个signal.service包，创建C类

    package signal.service;

import signal.entity.MyStack;

public class C {
    private MyStack myStack;
    public C(MyStack myStack)
    {
        super();
        this.myStack = myStack;
    }
    public void popService()
    {
        System.out.println("pop="+myStack.pop());
    }
}

    即在消费者类C中内聚一个MyStack对象，由构造方法给该MyStack对象赋值，调用MyStack的pop方法。

  4. 创建一个signal.thread包，创建P_Thread类

    package signal.thread;

import signal.service.P;

public class P_Thread extends Thread{
    private P p;
    public P_Thread(P p)
    {
        super();
        this.p=p;
    }

    @Override
    public void run() {
        while(true)
        {
            p.pushService();
        }
    }
}

    即通过构造方法将消费者P赋值给内聚对象P，再使用While调用P类的pushService()方法。

  5. 创建一个signal.thread包，创建C_Thread类

    package signal.thread;

import signal.service.C;
import signal.service.P;

public class C_Thread extends Thread{
    private C c;
    public C_Thread(C c)
    {
        super();
        this.c=c;
    }

    @Override
    public void run() {
        while(true)
        {
            c.popService();
        }
    }
}

    即通过构造方法将消费者C赋值给内聚对象C，再使用While调用C类的popService()方法。

  6. 在signal包中创建Test测试类

    package signal;

import signal.entity.MyStack;
import signal.service.C;
import signal.service.P;
import signal.thread.C_Thread;
import signal.thread.P_Thread;

public class Test {
    public static void main(String[] args) {
    	//操作栈对象
        MyStack myStack = new MyStack();
        //2个生产者
        P p1 = new P(myStack);
        P_Thread pThread1 = new P_Thread(p1);
        P p2 = new P(myStack);
        P_Thread pThread2 = new P_Thread(p2);

        //3个消费者
        C c1 = new C(myStack);
        C_Thread cThread1 = new C_Thread(c1);

        C c2 = new C(myStack);
        C_Thread cThread2 = new C_Thread(c2);

        C c3 = new C(myStack);
        C_Thread cThread3 = new C_Thread(c3);

        //生产者线程启动
        pThread1.start();
        pThread2.start();
        //消费者线程启动
        cThread1.start();
        cThread2.start();
        cThread3.start();
    }
}

    最后进行多对多操作栈的测试，实例化一个操作栈对象，给全部线程进行构造方法赋值。
    使用2个生产者线程以及3个消费者线程并启动。
    即多个线程抢一个锁，并且一次只能操作一个。

2.在管道中传递字节流

  1. 创建一个signal.service包，在包下创建一个WriteData类

    package signal.service;

import java.io.IOException;
import java.io.PipedOutputStream;

public class WriteData {
    public void writeMethod(PipedOutputStream out)  {
            try 
            {
                System.out.println("write:");
                for (int i = 0; i < 300; i++) 
                {
                    String outData = ""+(i+1);
                    out.write(outData.getBytes());
                    System.out.print(outData);
                }
                System.out.println();
           		out.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
       
    }
}

    即在WriteData类的writeMethod方法中实现操作字节输出流PipedOutputStream

  2. 创建一个signal.service包，在包下创建一个ReadData类

    package signal.service;     
import java.io.IOException;
import java.io.PipedInputStream;

public class ReadData {
    public void readMethod(PipedInputStream input) {
        try
        {
            System.out.println("read:");
            byte[] bytes = new byte[20];
            //将input中的字节流读取到字节数组byte中，一次读取20个。
            int readLength = input.read(bytes);
            while(readLength != -1)
            {
                //从字节数组byte中，读取从input字节流中读取到的全部字节并存储到newData中。
                String newData = new String(bytes,0,readLength);
                System.out.print(newData);
                //将input中的字节流读取到字节数组byte中，一次读取20个。
                readLength = input.read(bytes);
            }
            System.out.println();
        	input.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }
}

    即在ReadData类的readMethod方法中实现操作字节输入流PipedInputStream

  3. 创建一个signal.thread包，在包下创建一个WriteThread类

    package signal.thread;

import signal.service.WriteData;

import java.io.PipedOutputStream;

public class WriteThread extends Thread{
    private WriteData write;
    private PipedOutputStream out;
    public WriteThread(WriteData write,PipedOutputStream out)
    {
        this.write = write;
        this.out = out;
    }

    @Override
    public void run() {
        write.writeMethod(out);
    }
}

    即用构造方法给WriteData和PipedOutputStream对象赋值。在输入流线程的run方法中调用WriteData对象的writeMethod，并将PipedOutputStream 对象作为参数传入到writeMethod方法中。
    PipedOutputStream对象是输出字节流对象。

  4. 创建一个signal.thread包，在包下创建一个ReadThread类

    package signal.thread;

import signal.service.ReadData;

import java.io.PipedInputStream;


public class ReadThread extends Thread{
    private ReadData read;
    private PipedInputStream input;
    public ReadThread(ReadData read, PipedInputStream input)
    {
        this.read = read;
        this.input = input;
    }

    @Override
    public void run() {
        read.readMethod(input);
    }
}

    即用构造方法给ReadData 和PipedInputStream对象赋值。在输入流线程的run方法中调用ReadData 对象的readMethod，并将PipedInputStream 对象作为参数传入到readMethod方法中。
    PipedInputStream对象是输入字节流对象。

  5. 在signal包下创建Run类

    package signal;

import signal.service.ReadData;
import signal.service.WriteData;
import signal.thread.ReadThread;
import signal.thread.WriteThread;

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

public class Run {
    public static void main(String[] args) {
        try {
            WriteData writeData = new WriteData();
            ReadData readData = new ReadData();
            //实例化字节输入输出流对象
            PipedOutputStream pipedOutputStream = new PipedOutputStream();
            PipedInputStream pipedInputStream = new PipedInputStream();
            //将输入输出流对象进行connect关联
            pipedInputStream.connect(pipedOutputStream);
            //实例化读写线程
            ReadThread readThread = new ReadThread(readData, pipedInputStream);
            readThread.start();
            Thread.sleep(2000);

            WriteThread writeThread = new WriteThread(writeData, pipedOutputStream);
            writeThread.start();
        } catch (IOException e) {
            throw new RuntimeException(e);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

    即该测试类实例化读写线程时，通过构造方法将WriteData（ReadData）对象和字节流对象传入并给内聚对象赋值。
    在run方法中调用WriteData（ReadData）的wirteMethod（readMethod）方法，wirteMethod（readMethod）方法则去实现将字节流转换成字符串（字符串转换成字节流）的形式输出（输入）。
    即Thread对象->Data.Method->数据操作

3.在管道中传递字符流

字符流跟字节流进行线程通信的实现方式相同，只是流对象不同，字符流是PipedReader和PipedWriter。

4.ThreadLocal

ThreadLocal主要作用是将数据放入当前线程对象中的Map里。这个Map是Thread类的实例变量。
数据->ThreadLocal->currentThread()->Map
Map的key是ThreadLocal对象，value是存储的值，每个线程中Map的值只对当前线程可见，其他线程不可以访问当前对象中的Map的值。
ThreadLocal对象由JVM进行实例化。
threadLocals变量是ThreadLocalMap实例，ThreadLocalMap又是属于Thread对象，默认是包级访问，不能从外部直接访问该变量。ThreadLocal和Thread在同一个包中，所以可以使用ThreadLocal对象访问Thread中的ThreadLocalMap这个变量。
ThreadLocalMap使用Entry对象来存储key也就是ThreadLocal对象及value也就是传入的值。然后再将Entry对象存入数组table中。
实现步骤，即创建一个类，用来实例化并存放ThreadLocal对象。这个类继承ThreadLocal类，然后重写initialValue方法以实现第一次get的值不为null。
线程在使用时，引用该实例，并调用set方法进行存储数据，get取值即可。
ThreadLocalMap中的静态内置类Entry是弱引用类型。
当垃圾回收器(gc)扫描时发现弱引用的对象，则不管内存是否足够，都会回收弱引用对象。
即执行gc操作，ThreadLocal对象就立即销毁。代表key的值ThreadLocal对象会随着gc操作而销毁，释放内存空间，但value值却不会随着gc操作而销毁，导致内存溢出。可以通过调用ThreadLocal实例的remove方法进行清除。
即在ThreadLocalMap中的数据不再使用时，要手动执行ThreadLocal的remove方法。

5.InheritableThreadLocal

使用InheritableThreadLocal可以在子线程中取得父线程继承下来的值。
main线程即父线程，在main线程中进行调用InheritableThreadLocal实例的set方法进行赋值。
线程类继承Thread，再调用InheritableThreadLocal实例的get方法取值，此时能取到main线程存入的值。
即子线程获取的值是从父线程main继承的。
此时set方法还是ThreadLocal的set方法，因为
InheritableThreadLocal没有重写set方法。
通过在创建子线程时，子线程主动引用父线程里面的InheritableThreadLocal对象值。从而实现子线程继承父线程中InheritableThreadLocal对象的值。
init自动被Thread的构造方法调用，最后一个参数为boolean inheritThreadLocals代表当前线程是否会从父线程中继承值，这个值被永远传入true。即每一次都会继承父线程的值。
并且当父线程中的InheritableThreadLocal对象值不为空时，将父线程的InheritableThreadLocal对象值赋值给子线程的InheritableThreadLocal对象值。
string数据类型是不可变的，对string赋新的常量值会开辟新的内存空间。
反言之，可变的就是2个对象引用同一个地址，一个对象的属性改变，另一个也能感应到。即赋值时非开辟新的内存空间，而是从常量值中去找值，没有才开辟新的内存空间。
不可变类型，当子线程有最新值，父线程还是旧值;当父线程有最新值，子线程还是旧值。
可变类型，当父线程有最新值，子线程也是最新值;子线程有最新值，父线程也是最新值。
childValue方法，将传入的参数(父线程中的值)进行返回，重写时可以添加其他的数据。

总结

  1. 变量的并发访问
    (1)执行完notify后，按照执行wait的顺序唤醒其他线程，notify所在的同步代码块执行完才会释放对象锁，最后其他线程继续执行wait后的代码。
    (2)在同步代码块中，遇到异常导致线程终止，锁也会被释放。
    (3)在同步代码块中，执行了锁对象的wait方法，这个线程会立即释放对象锁，等待被唤醒。
    (4)一生产一消费可以使用wait/notify机制，条件判断可以用if。
    其中只要有一个属于多时，就要使用wait/notifyAll，并且条件判断要用while。

  2. wait，线程就进入等待状态，即暂停执行，并释放锁，直到调用notify()。即wait立即释放锁。wait是object类的方法。
    sleep不释放锁，从而能实现同步效果。
    在同步方法或同步块中调用wait()和notify()，即必须拿到锁对象，才能调用wait()和notify()。
    wait(long)，没有线程对锁进行notify，则超过这个时间后线程自动唤醒，此时等待重新持有锁。

  3. notify，顺序唤醒一个处于wait状态的线程，使其进入就绪状态。并且当前线程调用notify()后，需要当前线程执行完程序后，也就是退出synchronized代码块后，才会释放对象锁。即不立即释放锁。
    如果不存在wait状态的线程，则notify会被忽略。
    notify按照调用wait方法的线程顺序进行唤醒。
    notifyAll，逆序依次唤醒全部处于wait状态的线程，使其进入就绪状态。
    notify及notifyAll唤醒wait线程的顺序不是固定的，唤醒的顺序有正序、倒序、随机，取决于具体的JVM实现。

  4. 多生产与多消费，进入假死状态，就是线程进入waiting状态，如果全都线程都进入waiting状态，则程序就不再执行任何业务功能了，整个项目呈停止状态。
    使用wait/notify机制，但是notify唤醒的可能是同类，即生产者唤醒生产者，消费者唤醒消费者，从而导致所有线程进入waiting状态，即假死。可以使用wait/notifyAll机制来解决“假死”问题。

  5. 一生产多消费时，需要使用while做条件判断，防止条件发生改变时没有得到及时响应，以至于多个呈wait状态的线程被唤醒。
    就是说如果使用if进行条件判断，则它只判断一次条件，后面执行消费操作。因为生产者线程刚开始还未生产，多个消费线程都执行了if，都处于后面的消费操作;生产者生产后，消费者进行消费，后面notify或notifyAll又唤醒消费者，此时已经没有商品进行消费了，此时就会报错。
    与多生产多消费相同，需要使用wait/notifyAll机制防止假死。
    多生产一消费、多生产多消费与一生产多消费基本相同。即创建的线程实例数量不相同。

  6. 连续生产多个商品与连续消费多个商品。
    就是生产者线程商品后存储商品的容量有一个最大值;消费者线程从这个容量里取，然后进行消费。
    此时生产者和消费者还是每次能操作一个商品，但是能使用while连续多次操作，直到容量满/空。
    就是说生产者的生产线程多个，并且可以连续消费，还有一个生产检查和一个消费检查容量数量的线程。
    生产检查线程，当数据没有达到最大值，则notifyAll，唤醒所有线程进行生产及消费，并且该生产检查线程进入休眠状态。
    生产线程使用while检查容量是否达到最大值，达到最大值则进入wait状态，等待商品被消费线程消费。否则就生产一个商品，以此循环。
    消费检查线程，检查容量是否不为空，则notifyAll，唤醒所有线程进行生产及消费，并且该消费检查线程进入休眠状态。
    消费线程，使用while检查容量是否为空，为空则进入wait状态，等待商品被生产线程生产。否则就消费一个商品，以此循环。

  7. 通过管道进行线程间通信。
    Java JDK提供了4个类来使线程间可以进行通信，即PipedInputStream和PipedOutputStream、PipedReader和PipedWriter。
    字节流通信PipedInputStream和PipedOutputStream与字符流通信PipedReader和PipedWriter一样，创建实例后需要使用connect方法进行通信连接。
    即input连接output或者反过来都可以。
    字节流用来处理图片、图像、ppt和word文件等，也可以处理纯文本文件。
    字符流用来处理纯文本文件，但是不能处理图片等非纯文本文件。

  8. join方法，作用是使所属的线程对象x正常执行run()方法中的任务，而使当前线程z进行无限期阻塞，等待线程x销毁后再继续执行线程z后面的代码，具有串联的效果。
    类似于同步的运行效果，与synchronized不同的是，join使用wait()，而synchronized使用锁作为同步。
    join和interrupt方法共同使用且相遇时，会出现异常。
    join(long)，用于指定等待的时间，不管x线程是否执行完毕，时间到了并且重新获得锁，则当前线程会继续向后执行。如果没有重新获得锁，则一直尝试，直到获得锁为止。
    因为join(long)，内部使用wait(long)来实现，所以join(long)具有释放锁的特点。
    sleep(long)不释放锁。
    join(long millis,int nanos),即millis毫秒＋nanos纳秒为该线程终止的最长时间，nanos取值范围是0~999999。
    使用join，即相当于让该线程调用wait方法。

帅得真的是无敌了
关注
专栏目录
java多线程实现大批量数据导入源码
09-29
本项目以"java多线程实现大批量数据导入源码"为题，旨在通过多线程策略将大量数据切分，并进行并行处理，以提高数据处理速度。 首先，我们需要理解Java中的线程机制。Java通过`Thread`类来创建和管理线程。每个线程...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
Java 多线程
Su3253067688的博客
12-18 179
多线程（multithreading），是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。具有这种能力的系统包括对称多处理机、多核心处理器以及芯片级多处理或同时多线程处理器。在一个程序中，这些独立运行的程序片段叫作“线程”（Thread），利用它编程的概念就叫作“多线程处理”。2.原理实现多线程是采用一种并发执行机制并发：指两个或多个事件在同一时间段内发生。
Java 的 多线程&JUC
最新发布
qq_72343101的博客
05-14 911
进程：进程是程序的基本执行实体线程：线程是操作系统中能够进行运算调度的最小单位，它被包含在进程中，是进程的实际运作单位。例如：360软件在运行后，里面有许多功能（木马查杀，电脑清理，系统修复等）那么360这个软件本身就是一个进程，而木马查杀，电脑清理，系统修复等一系列功能就是线程线程的简单理解：应用软件中互相独立，又可以同时运行的的功能这种互相独立的功能比较多，就形成了多线程以前的代码也叫做单线程程序，因为是从头往下，依次进行的多线程程序的特点：能同时做多件事情多线程的应用场景。
java多线程
weixin_44134930的博客
11-20 260
线程创建的三种方法继承Thread 重写 run方法实现Runnable接口 重写 run方法实现Callable接口 重写call方法 return一个值调用Runnable 需要启动代理类 new Thread(new xxx)).start()
详解Java多线程处理List数据
08-26
详解Java多线程处理List数据 Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List...
JAVA多线程的使用场景与注意事项总结
08-26
JAVA多线程的使用场景与注意事项总结 Java多线程是Java语言中的一种重要机制，允许程序同时执行多个任务，以提高程序的执行效率和响应速度。在Java中，多线程可以通过继承Thread类、实现Runnable接口或使用线程池来...
Java多线程Executors批量执行数据实现限流
05-20
Java多线程实现数据切割批量执行，实现限流操作。 java线程池Executors实现数据批量操作。 批量异步Executors处理数据，实现限流操作，QPS限流。 线程池调用第三方接口限流实现逻辑。 案例适合： 1.批量处理大数据。...
java多线程（超详细）
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
java版简易 nc
wguangliang的专栏
05-30 2410
实现一个Java版的简易nc，用于方便windows上spark streaming的socketTextStream 的测试 界面如下 运行方式 有两种： 不添加端口号参数，直接运行的话，默认监听9999端口java nc 端口号   ，添加一个端口参数。 实现代码 import java.awt.BorderLayout; import java
用java实现nc功能实例
java专栏
05-24 1026
google_ad_client = "pub-8800625213955058";/* 336x280, 创建于 07-11-21 */google_ad_slot = "0989131976";google_ad_width = 336;google_ad_height = 280;//<script type="text/java
java多线程（详）
weixin_54107527的博客
03-16 5270
什么叫线程？ 那我们要先了解什么叫进程，线程依赖于进程而存在的。 进程：正在运行的程序 是系统进行资源调用和资源分配的独立单位 每一个进程都有它自己的内存空间和系统资源 线程：是进程中的单个顺序控制流，是一条执行路径 单线程：一个进程如果只有一条执行路径就是单线程程序 记事本程序：在调出页面设置的时候只能在关闭页面设置之后进行其他操作，否则无法进行其他操作。 多线程：一个进程如果只有多条执行路径就是多线程程序 扫雷程序：点击第一下时间开始计时，时间计时的同时可以玩扫雷游戏 ......
java多线程的常见例子
wenzhi的博客
09-13 6万+
本文有比较常见的java多线程问题的解决方法。对部分知识也有总结。
Java中多线程
07-17 1万+
所谓多线程，就是说一个应用程序有多条执行路径，每当我们打开一个应用程序的时候，就像当与打开了一个进程，而进程中执行的操作，就是线程。以迅雷为例，打开迅雷就相当于打开一个进程，下载文件的操作就是线程，多线程就是同时下载多个文件 在Java中有两种方式实现多线程分别是继承Thread类和实现Runnable接口 目录 一、继承Thread类 二、实现Runnable接口 三、继承Thread...
Java多线程详解
luojias的博客
05-09 606
1线程的创建和启动 1.1thread类创建线程类 package ThreadLearnDemo01; public class FirstThread extends Thread{ private int i; public void run(){ for(;i<100;i++) { System.out.println(this.getName()+" "+i); } } public
JAVA多线程实现的三种方式
热门推荐
步春良
07-31 56万+
JAVA多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。 1、继承Thread类实现多线程 继承Thread类的方法尽管被我列为一种多线程实现方式，但Thread本质上也是实现了Runnable接口的一个实例
Java多线程深度解析
"《Java多线程详解》- 汪文君" 本书是关于Java多线程编程的深度解析，作者汪文君分享了他在工作中和学习中的理解和实践经验。书中内容详细介绍了多线程的基本概念、Java对多线程的支持以及如何在实际编程中运用多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值