代码理解多线程（一）

最新推荐文章于 2024-04-24 13:31:12 发布
最新推荐文章于 2024-04-24 13:31:12 发布
阅读量192 收藏
点赞数 1
分类专栏： 多线程 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzqtty/article/details/87621563
版权

 

多线程访问会有什么问题？？

 

public class TestMyThread extends Thread{
    

    //共享变量
    private int a = 5;
    
    //重写run方法
    @Override
    public  void  run(){        
        a--;
        System.out.println("a is :"+ a);    
    }
    
    public static void main(String[] args) {
        
        
        //实列需要多线程的对象
        TestMyThread myThread = new TestMyThread();
        
        
        //创建多个线程实列
        Thread t1 = new Thread(myThread,"t1");
        Thread t2 = new Thread(myThread,"t2");
        Thread t3 = new Thread(myThread,"t3");
        Thread t4 = new Thread(myThread,"t4");
        Thread t5 = new Thread(myThread,"t5");
        
        
        
        //运行
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
        
        
    }
    
    
    
    
    
}

结果：

a is :3
a is :3
a is :2
a is :1
a is :0

a is :4
a is :3
a is :2
a is :1
a is :0

等等，你会发现每次出来的结果都不一样，这就是多线程访问的问题

 怎样解决？？？

package test19218;

import test517designpattern.test;

/**
 * @Description
 * @Author zengzhiqiang
 * @Date 2019年2月18日
 */

public class TestMyThread extends Thread{
    

    //共享变量
    private int a = 5;
    
    //重写run方法
    @Override
    public synchronized void  run(){        
        a--;
        System.out.println("a is :"+ a);    
    }
    
    public static void main(String[] args) {
        
        
        //实列需要多线程的对象
        TestMyThread myThread = new TestMyThread();
        
        //创建多个线程实列
        Thread t1 = new Thread(myThread,"t1");
        Thread t2 = new Thread(myThread,"t2");
        Thread t3 = new Thread(myThread,"t3");
        Thread t4 = new Thread(myThread,"t4");
        Thread t5 = new Thread(myThread,"t5");
        
        
        
        //运行
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
        
        
    }
    
    
    
    
    
}

 

 我们加了synchronize关键字

a is :4
a is :3
a is :2
a is :1
a is :0

 结果是我们想要的。

那么synchronize是锁的对象myThread ，还是那一段代码呢？

package test19218;

import test517designpattern.test;

/**
 * @Description
 * @Author zengzhiqiang
 * @Date 2019年2月18日
 */

public class TestMyThread extends Thread{
    
    //共享变量
    private int a = 5;
    
    //重写run方法
    @Override
    public synchronized void  run(){        
        a--;
        System.out.println("a is :"+ a);    
    }
    
    public static void main(String[] args) {
        
        
        //实列需要多线程的对象
        TestMyThread myThread = new TestMyThread();
        TestMyThread myThread2 = new TestMyThread();
        
        //创建多个线程实列
        Thread t1 = new Thread(myThread,"t1");
        Thread t2 = new Thread(myThread2,"t2");
        
        //运行
        t1.start();
        t2.start();
        
    }
    
}

 

 结果

a is :4
a is :4

 说明锁住的是代码。如果是锁住的对象，那么就应该减两次才对！！！

 /**
 * 关键字synchronized取得的锁都是对象锁，而不是把一段代码（方法）当做锁，
 * 所以代码中哪个线程先执行synchronized关键字的方法，哪个线程就持有该方法所属对象的锁（Lock），
 *
 * 在静态方法上加synchronized关键字，表示锁定.class类，类一级别的锁（独占.class类）。
 * @author alienware
 *
 */

 如果同一个对象，两个方法，一个用synchronize修饰，另一个不用，我访问非synchronize修饰的方法是否需要等待，其实就是是否会阻塞？

package test19218;

/**
 * @Description
 * @Author zengzhiqiang
 * @Date 2019年2月18日
 */

public class TestMyThread02 {

    String tag;

    public TestMyThread02(String tag) {
        this.tag = tag;
    }

    public TestMyThread02() {
    }

    // 共享变量
    private int a = 5;

    // 方法
    public synchronized void deNum(String tag) throws InterruptedException {
        a--;
        Thread.sleep(1000);
        System.out.println(tag + "---a is :" + a);
    }

    // 方法
    public  void adNum(String tag) {
        a++;
        System.out.println(tag + "---a is :" + a);
    }

    public static void main(String[] args) {

        final String t1 = "t1";
        final String t2 = "t2";

        // 实列需要多线程的对象
        final TestMyThread02 myThread01 = new TestMyThread02();
        // final TestMyThread02 myThread02 = new TestMyThread02();

        // 创建多个线程实列
        Thread th = new Thread(new Runnable() {

            @Override
            public void run() {

                try {
                    myThread01.deNum(t1);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }
        });

        Thread th1 = new Thread(new Runnable() {

            @Override
            public void run() {

                myThread01.adNum(t2);

            }
        });

        // 运行
        th.start();
        th1.start();
    }

}

 

 结果

t2---a is :5
t1---a is :5

 t2先执行了，所以并不会阻塞。

如果两个方法都加上synchronize呢？

package test19218;

/**
 * @Description
 * @Author zengzhiqiang
 * @Date 2019年2月18日
 */

public class TestMyThread02 {

    String tag;

    public TestMyThread02(String tag) {
        this.tag = tag;
    }

    public TestMyThread02() {
    }

    // 共享变量
    private int a = 5;

    // 方法
    public synchronized void deNum(String tag) throws InterruptedException {
        a--;
        Thread.sleep(1000);
        System.out.println(tag + "---a is :" + a);
    }

    // 方法
    public synchronized  void adNum(String tag) {
        a++;
        System.out.println(tag + "---a is :" + a);
    }

    public static void main(String[] args) {

        final String t1 = "t1";
        final String t2 = "t2";

        // 实列需要多线程的对象
        final TestMyThread02 myThread01 = new TestMyThread02();
        // final TestMyThread02 myThread02 = new TestMyThread02();

        // 创建多个线程实列
        Thread th = new Thread(new Runnable() {

            @Override
            public void run() {

                try {
                    myThread01.deNum(t1);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }
        });

        Thread th1 = new Thread(new Runnable() {

            @Override
            public void run() {

                myThread01.adNum(t2);

            }
        });

        // 运行
        th.start();
        th1.start();
    }

}

 

 t1---a is :4
t2---a is :5

 进行阻塞

所以，当同一个对象中的两个方法有逻辑联系的时候，你其中一个加了synchronize，那么你另一个也应该加上，才能保证返回结果的正确。

 

锁对象改变问题

package test19218;

/**
 * @Description
 * @Author zengzhiqiang
 * @Date 2019年2月18日
 */

public class TestMyThread02 {

    private String tag = "tag";

    public TestMyThread02() {
    }

    // 共享变量
    private int a = 5;

    // 方法
    public void deNum() throws InterruptedException {

        synchronized (tag) {
            tag = "change tag";

            System.out
                    .println(Thread.currentThread().getName() + "sleep begin");
            Thread.sleep(6000);
            System.out.println(Thread.currentThread().getName() + "sleep over");
        }

    }

    // 方法
    public synchronized void adNum(String tag) {
        a++;
        System.out.println(tag + "---a is :" + a);
    }

    public static void main(String[] args) {

        final String t1 = "t1";
        final String t2 = "t2";

        // 实列需要多线程的对象
        final TestMyThread02 myThread01 = new TestMyThread02();
        // final TestMyThread02 myThread02 = new TestMyThread02();

        // 创建多个线程实列
        Thread th = new Thread(new Runnable() {

            @Override
            public void run() {

                try {
                    myThread01.deNum();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }
        }, t1);

        Thread th1 = new Thread(new Runnable() {

            @Override
            public void run() {

                try {
                    myThread01.deNum();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }
        }, t2);

        // 运行
        th.start();

        try {
            th1.sleep(100);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        th1.start();
    }

}

 

 th进入锁以后改变对象，th1立刻就进入，没有等t1执行完成

如果不改变锁对象，那么th1将等th执行完成后才进入。

 死锁问题，

在设计程序时就应该避免双方相互持有对方的锁的情况

package com.bjsxt.base.sync006;

/**
 * 死锁问题，在设计程序时就应该避免双方相互持有对方的锁的情况
 * @author alienware
 *
 */
public class DeadLock implements Runnable{

    private String tag;
    private static Object lock1 = new Object();
    private static Object lock2 = new Object();
    
    public void setTag(String tag){
        this.tag = tag;
    }
    
    @Override
    public void run() {
        if(tag.equals("a")){
            synchronized (lock1) {
                try {
                    System.out.println("当前线程 : "  + Thread.currentThread().getName() + " 进入lock1执行");
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock2) {
                    System.out.println("当前线程 : "  + Thread.currentThread().getName() + " 进入lock2执行");
                }
            }
        }
        if(tag.equals("b")){
            synchronized (lock2) {
                try {
                    System.out.println("当前线程 : "  + Thread.currentThread().getName() + " 进入lock2执行");
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock1) {
                    System.out.println("当前线程 : "  + Thread.currentThread().getName() + " 进入lock1执行");
                }
            }
        }
    }
    
    public static void main(String[] args) {
        
        DeadLock d1 = new DeadLock();
        d1.setTag("a");
        DeadLock d2 = new DeadLock();
        d2.setTag("b");
        
        Thread t1 = new Thread(d1, "t1");
        Thread t2 = new Thread(d2, "t2");
        
        t1.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();
    }
    

    
}

 

同一对象属性的修改不会影响锁的情况

 

package com.bjsxt.base.sync006;
/**
 * 同一对象属性的修改不会影响锁的情况
 * @author alienware
 *
 */
public class ModifyLock {
    
    private String name ;
    private int age ;
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
    public synchronized void changeAttributte(String name, int age) {
        try {
            System.out.println("当前线程 : "  + Thread.currentThread().getName() + " 开始");
            this.setName(name);
            this.setAge(age);
            
            System.out.println("当前线程 : "  + Thread.currentThread().getName() + " 修改对象内容为： "
                    + this.getName() + ", " + this.getAge());
            
            Thread.sleep(2000);
            System.out.println("当前线程 : "  + Thread.currentThread().getName() + " 结束");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) {
        final ModifyLock modifyLock = new ModifyLock();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                modifyLock.changeAttributte("张三", 20);
            }
        },"t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                modifyLock.changeAttributte("李四", 21);
            }
        },"t2");
        
        t1.start();
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();
    }
    
}

 

 使用synchronized代码块加锁,比较灵活

 

package com.bjsxt.base.sync006;

/**
 * 使用synchronized代码块加锁,比较灵活
 * @author alienware
 *
 */
public class ObjectLock {

    public void method1(){
        synchronized (this) {    //对象锁
            try {
                System.out.println("do method1..");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    public void method2(){        //类锁
        synchronized (ObjectLock.class) {
            try {
                System.out.println("do method2..");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    private Object lock = new Object();
    public void method3(){        //任何对象锁
        synchronized (lock) {
            try {
                System.out.println("do method3..");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    
    public static void main(String[] args) {
        
        final ObjectLock objLock = new ObjectLock();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                objLock.method1();
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                objLock.method2();
            }
        });
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                objLock.method3();
            }
        });
        
        t1.start();
        t2.start();
        t3.start();
        
        
    }
    
}

 

 synchronized代码块对字符串的锁，注意String常量池的缓存功能

package com.bjsxt.base.sync006;
/**
 * synchronized代码块对字符串的锁，注意String常量池的缓存功能
 * @author alienware
 *
 */
public class StringLock {

    public void method() {
        //new String("字符串常量")
        synchronized ("字符串常量") {
            try {
                while(true){
                    System.out.println("当前线程 : "  + Thread.currentThread().getName() + "开始");
                    Thread.sleep(1000);        
                    System.out.println("当前线程 : "  + Thread.currentThread().getName() + "结束");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    public static void main(String[] args) {
        final StringLock stringLock = new StringLock();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                stringLock.method();
            }
        },"t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                stringLock.method();
            }
        },"t2");
        
        t1.start();
        t2.start();
    }
}

 

 使用synchronized代码块减小锁的粒度，提高性能

package com.bjsxt.base.sync006;

/**
 * 使用synchronized代码块减小锁的粒度，提高性能
 * @author alienware
 *
 */
public class Optimize {

    public void doLongTimeTask(){
        try {
            
            System.out.println("当前线程开始：" + Thread.currentThread().getName() +
                    ", 正在执行一个较长时间的业务操作，其内容不需要同步");
            Thread.sleep(2000);
            
            synchronized(this){
                System.out.println("当前线程：" + Thread.currentThread().getName() +
                    ", 执行同步代码块，对其同步变量进行操作");
                Thread.sleep(1000);
            }
            System.out.println("当前线程结束：" + Thread.currentThread().getName() +
                    ", 执行完毕");
            
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) {
        final Optimize otz = new Optimize();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                otz.doLongTimeTask();
            }
        },"t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                otz.doLongTimeTask();
            }
        },"t2");
        t1.start();
        t2.start();
        
    }
    
    
}

 

 多个addAndGet在一个方法内是非原子性的，需要加synchronized进行修饰，保证4个addAndGet整体原子性

package other;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Description
 * @Author zengzhiqiang
 * @Date 2019年2月19日
 */

public class AtomicTest {

    //变量为atomic系列
    private  AtomicInteger num = new AtomicInteger(0);
    
    //多次自增 synchronized
    public   void addNum(){
     int i =    num.incrementAndGet();
     System.out.println("now  num is :" + i);
    
     num.incrementAndGet();
     num.incrementAndGet();
     num.incrementAndGet();
     num.incrementAndGet();
    
    }
    
    
    public static void main(String[] args) {
        
        
        //实列需要多线程对象
        final AtomicTest test  = new AtomicTest();
        
        
        //起多个线程运行
        for(int i = 0;i<=100;i++){
            
            //System.out.println("now time is : "+ i);
            Thread t = new Thread(new Runnable() {                
                @Override
                public void run() {
                    // TODO Auto-generated method stub
                    test.addNum();
                }
            });
            
            //启动
            t.start();
        }
    }
    
}

 

结果：

now  num is :418
now  num is :433
now  num is :432

 结果是乱的，加上synchronize之后

    //多次自增 synchronized
    public  synchronized   void addNum(){
     int i =    num.incrementAndGet();
     System.out.println("now  num is :" + i);
    
     num.incrementAndGet();
     num.incrementAndGet();
     num.incrementAndGet();
     num.incrementAndGet();
    
    }

 now  num is :486
now  num is :491
now  num is :496
now  num is :501

 输出结果总是一直且有序

 volatile关键字不具备synchronized关键字的原子性（同步）

 

package other;

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

import com.mysql.fabric.xmlrpc.base.Array;

/**
 * @Description
 * @Author zengzhiqiang
 * @Date 2019年2月19日
 */

public class VolatileTest {

    //变量
    private volatile int num  = 0;
    
    
    //变量的自增   synchronized
    public  void addNum(){
        num++;
        num++;
        System.out.println("now num is :" + num);
    }
    
    public static void main(String[] args) {
        
        //多线程实列对象
        final VolatileTest test =  new VolatileTest();
        
        //定义多线程列表
        List<Thread> list = new  ArrayList<Thread>();
        
        
        //初始化多个线程
        for(int i = 0;i<100;i++){
            Thread t = new Thread(new Runnable() {
                
                @Override
                public void run() {
                test.addNum();
                    
                }
            });
            
            list.add(t);
        }
        
        
        //启动多线程
        for(Thread th:list){
            th.start();
        }
        
    }
    
}

 

 结果

now num is :188
now num is :188
now num is :186
now num is :186

 无序，显示不正确，但是结果为200，正确

使用synchronize修饰

    //变量的自增   synchronized
    public  synchronized  void addNum(){
        num++;
        num++;
        System.out.println("now num is :" + num);
    }

结果

now num is :194
now num is :196
now num is :198
now num is :200

 有序，显示正确，且结果正确。

zzqtty
关注
专栏目录
多线程编程示例源代码
07-27
多线程编程示例代码，包含CreateThread _beginthread AFXbeginThread 3个API的示例
多线程测试代码多线程测试代码
11-08
在`mthread`这个压缩包中，可能包含了使用上述技术编写的测试代码示例，你可以通过查看和运行这些代码来更好地理解和学习多线程编程。 总的来说，多线程编程是现代软件开发中的关键技能，无论是在Win32 API、C运行...
多线程代码实现（一）
xulong5000的专栏
06-27 1993
//dll里面的内容 public class PushStreamContent : HttpContent { public PushStreamContent(Action<Stream, HttpContent, TransportContext> onStreamAvailable); } 有2种调用方式 第1种--使用...
Java-笔记18
weixin_33949359的博客
05-28 297
线程安全问题： package com.atguigu.java; /** * 例子：创建三个窗口卖票，总票数为100张.使用实现Runnable接口的方式 * * 1.问题：卖票过程中，出现了重票、错票 -->出现了线程的安全问题 * 2.问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线...
多线程的代码案例（详解）
最新发布
weixin_63018754的博客
04-24 1061
学习编程,需要必要的重复的。一个代码,反复写多遍,是非常正常的情况。如果细节很多,很难一次就把所有的细节都注意到都理解清楚。
学不懂多线程？代码加实例详解帮你深入理解多线程（1）
MacondoMayor的博客
05-02 1232
系列文章目录 操作系统系列之进程调度的基本过程 文章目录系列文章目录前言1. 什么是进程？2. 什么是线程？3. 进程与线程的内存分配3.1 单线程的程序是如何执行的？总结 前言 🌴很多同学在学习多线程的时候经常被搞得一头雾水，分不清楚单线程多线程进程之间的关系，更别说从操作系统层面去理解它们的原理了，那么本文就通过具体的代码➕实例➕画图详解，帮助大家更加深入的理解多线程❗️ 1. 什么是进程？ 🌴在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，而进程是程序的执
C#多线程编程实战 源代码
12-06
因此，现代应用程序开发人员必须深入理解多线程。 本书是一本通俗易懂的C#多线程编程指南，通过70多个容易理解的示例，循序渐进地讲解C#5.0中的异步及并发编程，引导读者了解Windows下C#多线程编程的多样性。 通过...
QT多线程实战源代码（QThread）
04-20
QT多线程实战源代码（QThread）是一个关于如何在QT框架中利用多线程进行高效编程的示例集合。QT是一个跨平台的C++库，广泛用于开发GUI应用程序，而QThread是QT提供的一种线程管理机制，使得开发者可以在QT环境中方便...
Python多线程扫描端口代码示例
09-20
总结来说，本文所展示的Python多线程端口扫描代码示例是一个很好的学习案例，对于希望深入理解和掌握Python网络编程和多线程编程的开发者而言，这个示例可以作为一个起点。通过学习和实践这段代码，开发者能够加深对...
多线程几种常用方法代码
code_mzh的博客
06-27 885
线程只能start一次 1.sleep，休眠 //增加事故发生问题 public class TestSleep implements Runnable{ //票 private int ticketNum=10; @Override public void run() { while(true){ if(ticketNum<=0){ break; }
需要更快的代码？ 尝试多线程
编程故事的地方
09-29 101
在程序员的职业生涯中，有时会意识到他们的代码只需要运行得更快。 无论是创建低延迟API还是解析数十亿个数据点的程序，速度都是一个巨大的因素。 如果代码运行太慢，该怎么办？ 幸运的是，编程工具带中有很多工具可以使代码运行更快。 您可能想到的第一个想法是缓存。 但是，当无法选择缓存时该怎么办？ 另一个可行的选择是多线程。 为了讨论多线程，重要的是讨论什么是进程和线程。 用最简单的术语来说，您可...
多线程（看这篇就够了！最全）
热门推荐
JavaSupeMan的博客
05-13 2万+
进程是电脑程序运行的最小单位，而线程则是进程的最小执行单位 多线程呢就是指一个进程运行时，多个线程并行交替执行的过程。可以提高代码的执行效离 解决多线程安全 1.使用synchronized synchronized的三种应用方式 修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁 修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁 修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。 2.使用lock锁 举例： public class a
如何理解程序、进程、线程？
qq_37992662的博客
03-08 574
三者之间的形象化理解： 程序：代码实现了功能，就是程序，是静态的；程序是存储在磁盘上。 例如：实现eclipse的代码 进程：执行中的程序就是进程，是动态的； 例如：运行eclipse出现的界面 线程：进程内的一个执行单元,也是进程内的可调度实体，可以并发执行提高了进程的效率。 程序与进程的区别： 程序是指令的有序集合，其本身没有任何运行的含义，是一个静态的概念。而进程是程序在处理机上的...
Java多线程超详细总结
weixin_49042230的博客
12-16 257
Java多线程技术 进程与线程 进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间。打开任务管理器可以看到当前电脑中正在运行的进程 线程：是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行.。 一个进程最少有一个线程。 线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程。 可以看到我的电脑中有259个进程，三千多个线程。（相当于我的电脑中有259个程序，每个程序大于有10多个线程） JAVA线程创建的三种方式 1、Thre
【并发编程】多线程先执行完的先取结果的解决方案：CompletionService
qq_35436158的博客
02-20 804
多线程一边生成任务,一边获取任务的返回值，让等待时间短的线程优先返回结果，这就是CompletionService。
Java多线程（附代码示例）
SimpleZihao的博客
10-08 1735
1. 一些概念 线程就是独立的执行路径 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程 main()称之为主线程，是系统的入口，用于执行整个程序 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序不能人为干预 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制 线程会带来额外的开销，如cpu调度时间，并发控制开销 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致 2. 开启多线程的几种方式 1. 继承Thre
Java多线程代码编写
悦分享
08-19 3561
Java多线程代码编写 什么是多线程 并发和并行 　并行：指两个或多个时间在同一时刻发生（同时发生）； 　并发：指两个或多个事件在一个时间段内发生。 在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单 CPU 系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。 ...
Java多线程代码
ljl1015ljl的博客
02-28 604
考研继续回顾中。。。 一个应用程序包含n个进程 一个进程包含n个线程 sleep sleep 设置休眠的时间,单位毫秒，当一个线程遇到 sleep 的时候，就会睡眠，进入到阻塞状态,放弃 CPU，腾出 cpu 时间片，给其他线程用，所以在开发中通常我们会这样做，使其他的线程能够取得 CPU 时间片，当睡眠时间到达了，线程会进入可运行状态，得到 CPU 时间片继续执行，如果线程在睡眠状态被中断...
深入理解Delphi多线程编程
Delphi的多线程功能在16位Windows上不被支持，因此32位Delphi程序的多线程代码无法在16位环境下编译。在16位的Windows系统中，多任务是协作式的，依赖于应用程序的合作，而在32位的Windows（如Win32）中，操作系统...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值