多线程----Thread类，Runnable接口，线程池，Callable接口，线程安全

最新推荐文章于 2023-01-11 21:35:44 发布
最新推荐文章于 2023-01-11 21:35:44 发布
阅读量213 收藏
点赞数
文章标签： java 操作系统 运维
原文链接：http://www.cnblogs.com/hzhjxx/p/10205953.html
版权

1概念

1.1进程

进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。

任务管理器中：

 

 

1.2线程

线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

 

简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程

 

1.3多线程

就是一个程序中有多个线程在同时执行。

单线程程序：多个任务只能依次执行。只有一个线程， 例：main方法中调用多个方法，效率较低

 

多线程程序：多个任务可以同时执行。

 

1.4程序运行原理 

分时调度

所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

抢占式调度

优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

 

大部分操作系统都支持多进程并发运行，现在的操作系统几乎都支持同时运行多个程序。此时，这些程序是在同时运行，”感觉这些软件好像在同一时刻运行着“。

实际上，CPU(中央处理器)使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。

其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

 

1.5主线程

程序从上往下执行的过程：

javac编译----JVM运行Demo01----找到main方法，运行----找到操作系统OS，开启线程

对于CPU就有了一条执行路径，运行方法main的这条路径就叫main，即主线程。

例：

public class Demo01 {
	//主线程
	public static void main(String[] args) {
		method01();
		System.out.println("-9的绝对值是："+Math.abs(-9));
	}
	public static void method01(){
		for(int i=0;i<10;i++){
			System.out.println(i);
		}
	}
}

加一条错误语句：

 

 

可以看到异常发生在main线程中

 

2 Thread类

Thread是程序中的执行线程。Java 虚拟机允许应用程序并发地运行多个执行线程。

  

 

常用方法：

 

 

创建新执行线程有两种方法：

2.1方法1

定义Thread子类，继承Thread，重写run方法

在测试类中创建Thread子类对象

子类对象调用start方法，并且只能调用一次

 

例：

public class ThreadDemo extends Thread{	
	public void run() {
		for(int i=0;i<10;i++){
			System.out.println("Thread:"+i);
		}
	}
}

 

public class Test01 {
	public static void main(String[] args) {
		ThreadDemo td=new ThreadDemo();
		td.start();
		for(int i=0;i<10;i++){
			System.out.println("main:"+i);
		}
	}
}

 

start()方法的两个任务：

1）让线程执行

2）让JVM调用线程中的run方法

内存图：

 

图说明：

Main进栈

看到New Thread，start(),会开线程，会再开一个新的栈，run方法进入新栈

两个栈就是两个线程

每new一个Thread，就多一个栈 

 

注意：要执行start方法，不是run方法，

 

 

这就不是多线程了，是正常调用方法。

 

2.2获取线程名称

 

例：

public class ThreadDemo extends Thread{	
	public void run() {
		System.out.println("线程名为："+getName());
	}
}

 

public class Test02 {
	public static void main(String[] args) {
		ThreadDemo td=new ThreadDemo();
		td.run();
		Thread td2=Thread.currentThread();
		System.out.println("主线程名为："+td2.getName());
	}
}

 

注意：主线程的名字只能用Thread.currentThread()这种方式获取，如果这样：

 

这里因为main方法是static，而getName()不是static，静态不能调用非静态，所以即使Test03继承了Thread也不能直接用getName()。

 

2.3修改线程名称（了解即可，尽量不要修改，没有必要）

1）setName()方法

public class ThreadDemo extends Thread{
	public void run() {		
		System.out.println(getName());
	}
}

 

public class Test03 extends Thread{
	public static void main(String[] args) {
		ThreadDemo td=new ThreadDemo();	
		td.setName("改名1");
		td.run();
	}
}

 

2）构造方法

public class ThreadDemo extends Thread{
	public ThreadDemo(){
		
	}
	public ThreadDemo(String name){
		super(name);
	}	
	
	public void run() {			
		System.out.println(getName());
	}
}

 

public class Test03 extends Thread{
	public static void main(String[] args) {
		ThreadDemo td=new ThreadDemo("改名2");			
		td.run();
	}
}

 

Tips：主线程无法改名，就叫main

 

2.4 sleep()方法 

public class ThreadDemo extends Thread{	
	public void run() {			
		for(int i=0;i<5;i++){
			try {
				sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(i);
		}
	}
}　

 

public class Test03 extends Thread{
	public static void main(String[] args) {
		ThreadDemo td=new ThreadDemo();			
		td.run();
	}
}

 

3创建线程方式2—实现Runnable接口

3.1步骤

  1. 创建实现类，实现Runnable接口，重写run方法
  2. 在测试类中创建实现类对象，创建线程对象
  3. 将实现类对象传入线程对象的构造方法
  4. 用线程对象开启线程 

例：

public class MyRunnable implements Runnable{
	public void run() {		
		for(int i=0;i<10;i++){
			System.out.println(Thread.currentThread().getName()+"："+i);
		}
	}
}

 

public class Demo01 {
	public static void main(String[] args) {
		//创建线程任务对象
		MyRunnable mr=new MyRunnable();
		//创建线程对象1
		Thread t1=new Thread(mr);
		//开启线程1
		t1.start();
		
		//创建线程对象2
		Thread t2=new Thread(mr);
		//开启线程2
		t2.start();
	}
}

 

3.2好处

实现Runnable接口，避免了继承Thread类的单继承局限性，较为常用

实现Runnable接口的方式，更加的符合面向对象，线程分为两部分，一部分线程对象，一部分线程任务。

继承Thread类，线程对象和线程任务耦合在一起。一旦创建Thread类的子类对象，既是线程对象，有又有线程任务。实现runnable接口，将线程任务单独分离出来封装成对象，类型就是Runnable接口类型。Runnable接口对线程对象和线程任务进行解耦。

 

总结：把线程任务的定义，和线程的创建，分开了

高内聚，低耦合

 

3.3线程的匿名内部类使用

public class Demo02 {
	public static void main(String[] args) {		
		Runnable r=new Runnable(){			
			public void run() {
				System.out.println("重写后的run方法");				
			}			
		};
		//创建线程
		Thread t=new Thread(r);
		//开启线程
		t.start();	
	}
}

 

简写：

public class Demo2 {
	public static void main(String[] args) {
		new Thread(new Runnable(){			
			public void run() {
				System.out.println("重写后的run方法");
			}			
		}).start();
	}
}

 

4线程的状态

在Thread类中有个内部类：

 

线程状态。线程可以处于下列状态之一：

NEW
至今尚未启动的线程处于这种状态。

RUNNABLE
正在 Java 虚拟机中执行的线程处于这种状态。

BLOCKED
受阻塞并等待某个监视器锁的线程处于这种状态。

WAITING
无限期地等待另一个线程来执行某一特定操作的线程处于这种状态。

TIMED_WAITING
等待另一个线程来执行取决于指定等待时间的操作的线程处于这种状态。

TERMINATED
已退出的线程处于这种状态。

 

图示：

 

5线程池

5.1概念

线程池，其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。

 

5.2使用线程池方式--Runnable接口 

通常，线程池都是通过线程池工厂创建，再调用线程池中的方法获取线程，再通过线程去执行任务方法。

1）Executors：线程池创建工厂类

public static ExecutorService newFixedThreadPool(int nThreads)：返回线程池对象

2）ExecutorService：线程池类

Future<?> submit(Runnable task)：获取线程池中的某一个线程对象，并执行

3）Future接口：用来记录线程任务执行完毕后产生的结果。

 

使用线程池中线程对象的步骤：

　　创建线程池对象

　　创建Runnable接口子类对象

　　提交Runnable接口子类对象

　　关闭线程池

 

例：

public class MyRunnable implements Runnable{
	public void run() {		
		for(int i=0;i<5;i++){
			System.out.println(Thread.currentThread().getName()+"："+i);
		}
	}
}

 

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

public class Demo03 {
	public static void main(String[] args) {
		//从线程池工厂获取线程池对象
		ExecutorService es=Executors.newFixedThreadPool(2); //2条线程的线程池
		//线程池中抽取一个有空的线程执行线程任务
		es.submit(new MyRunnable());
		es.submit(new MyRunnable());		
		//销毁线程池
		es.shutdown();
	}
}

 

5.3使用线程池方式—Callable接口

1）Callable接口：

　　与Runnable接口功能相似，用来指定线程的任务。其中的call()方法，用来返回线程任务执行完毕后的结果，call方法可抛出异常。

2）ExecutorService：线程池类

　　<T> Future<T> submit(Callable<T> task)：获取线程池中的某一个线程对象，并执行线程中的call()方法

3）Future接口：用来记录线程任务执行完毕后产生的结果。

 

使用线程池中线程对象的步骤：

　　创建线程池对象

　　创建Callable接口子类对象

　　提交Callable接口子类对象

　　关闭线程池

 

例：

public class MyCallable implements Callable<String>{	
	public String call() throws Exception {	
		return "abc";
	}
}　

 

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

public class Demo01 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		//从线程池工厂获取线程池对象
		ExecutorService es=Executors.newFixedThreadPool(2);
		//获取call方法执行后的Future对象		
		Future<String> str=es.submit(new MyCallable());
		//从Future对象中获取返回值
		String s=str.get();
		System.out.println(s);
		//销毁线程池
		es.shutdown();	
	}
}

 

5.4练习：从1到100的和，从1到200的和

import java.util.concurrent.Callable;

public class CallSum implements Callable<Integer>{
	//定义成员变量
	private int num;
	
	//构造方法
	public CallSum(){		
	};	
	public CallSum(int num){
		this.num=num;
	};
	
	//线程任务
	public Integer call() throws Exception {
		int sum=0;
		for(int i=0;i<=num;i++){
			sum+=i;
		}
		return sum;
	}
}

 

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

public class Test {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		ExecutorService es=Executors.newFixedThreadPool(2);
		
		Future<Integer> f=es.submit(new CallSum(100));
		System.out.println(f.get());
		
		Future<Integer> f2=es.submit(new CallSum(200));
		System.out.println(f2.get());
		
		es.shutdown();
	}
}

 

6 线程安全

6.1线程安全

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

 

例：电影院卖票

 

 

代码示例：

public class MyTicker implements Runnable{
    private int ticket=100; //100张票
    //线程任务
    public void run() {
        while(true){
            if(ticket>0){
                try {
                    Thread.sleep(10);  //模拟资源被抢占
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"出售第"+ticket--+"张票");
            }
        }        
    }    
}

 

public class SaleTicket {
    public static void main(String[] args) {
        //创建线程任务
        MyTicker mt=new MyTicker();
        //创建线程
        Thread t0=new Thread(mt);
        Thread t1=new Thread(mt);
        Thread t2=new Thread(mt);        
        //开启线程
        t0.start();
        t1.start();
        t2.start();    
    }
}

 

在多线程访问同一个资源的时候，往往会出现安全问题。虽然不是一定发生，但是只要可能发生，这就是多线程的安全隐患，是不允许的。 

其实，线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。

 

6.2线程同步

java中提供了线程同步机制，它能够解决上述的线程安全问题。

线程同步的方式有两种：

　　方式1：同步代码块

　　方式2：同步方法

关键字：Synchronized（同步）

 

6.2.1同步代码块

　　在代码块声明上 加上synchronized

　　synchronized (锁对象) {

　　　　可能会产生线程安全问题的代码

　　}

注意：

1）同步代码块中的锁对象可以是任意的对象；但多个线程时，要使用同一个锁对象才能够保证线程安全。

2）把对共享数据的操作括起来

3）锁对象：定义成成员变量

 

修改后：

public class MyTicker implements Runnable{
    private int ticket=100; //100张票
    private Object obj=new Object(); //锁对象
    //线程任务
    public void run() {
        while(true){
            synchronized (obj) {
                if(ticket>0){
                    try {
                        Thread.sleep(10); //模拟资源被抢占
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"出售第"+ticket--+"张票");
                }
            }            
        }        
    }    
}

 

原理图：

 

当t0进来时，不管是否休眠，其他线程都不能进来，当一个线程进入数据操作时，无论是否休眠，其他线程只能等待。

 

6.2.2同步方法

在方法声明上加上synchronized

　　public synchronized void method(){

    　　可能会产生线程安全问题的代码

　　}

同步方法中的锁对象是 this 

public class MyTicker2 implements Runnable {
    private int ticket = 100; // 100张票    
    
    public synchronized void sale(){
        //可能会产生线程安全的代码
        if (ticket > 0) {
            try {
                Thread.sleep(10); // 模拟资源被抢占
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "出售第" + ticket-- + "张票");
        }
    }
    
    // 线程任务
    public void run() {        
        while (true) {
            sale();
        }
    }
}

 

静态同步方法: 在方法声明上加上static synchronized

　　public static synchronized void method(){

　　　　可能会产生线程安全问题的代码

　　}

注意：

静态同步方法中的锁对象是 类名.class（本类字节码对象，以后学反射再了解）

静态不能访问非静态，所以要把成员变量也加上static

 

Tips：

1）同步怎么保证安全性？

　　没有锁的线程不能执行只能等待

2）加了同步，线程进入同步判断锁时，获取锁，释放锁，会导致运行速度下降

3）StringBuffer里面所有方法都加了关键字，所以慢，但安全

　　StringBuilder没有加，所以快，但不安全

 

 

总结：

单线程不会出现安全问题

只有多个线程共享同一个资源时，才会出现安全问题

 

6.3 Lock接口

Jdk1.5以后出现的用来替代synchronized

Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。

常用方法：

 

没有static，所以要用子类对象调用

锁对象就是Lock对象 

private Lock lock=new ReentrantLock();

 

例：

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

public class MyTicker3 implements Runnable {
    private int ticket = 100; // 100张票
    // 创建Lock接口实现类对象
    private Lock lock = new ReentrantLock();

    // 线程任务
    public void run() {
        while (true) {
            // 获取锁
            lock.lock();
            if (ticket > 0) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "出售第" + ticket-- + "张票");
            }
            // 释放锁
            lock.unlock();
        }
    }
}

 

6.4死锁

同步锁使用的弊端：当线程任务中出现了多个同步(多个锁)时，如果同步中嵌套了其他的同步。这时容易引发一种现象：程序出现无限等待，这种现象我们称为死锁。这种情况能避免就避免掉。

 

死锁，两个线程互相等待

前提：必须是多线程之间出现的同步嵌套

 

代码示例：

public class LockA {
    private LockA(){
        
    }
    public final static LockA locka=new LockA();     
}

 

public class LockB {
    private LockB(){
        
    }
    public final static LockB lockb=new LockB();
}

 

public class DeadLock implements Runnable{
    private int i=0;    
    public void run(){
        while(true){
            if(i%2==0){
                //先进A同步，再进B同步
                synchronized (LockA.locka) {
                    System.out.println("if...locka");
                    synchronized (LockB.lockb) {
                        System.out.println("if...lockb");
                    }
                }
            }else{
                //先进B同步，再进A同步
                synchronized (LockB.lockb) {
                    System.out.println("else...lockb");
                    synchronized (LockA.locka) {
                        System.out.println("else...locka");
                    }
                }
            }
            i++;
        }
    }
}

 

public class Demo01 {
    public static void main(String[] args) {
        DeadLock dl=new DeadLock();
        Thread t0=new Thread(dl);
        Thread t1=new Thread(dl);
        t0.start();
        t1.start();    
    }
}

 

死锁无法解决，只能避免。

 

6.5等待唤醒机制

6.5.1定义

线程之间的通信：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。通过一定的手段使各个线程能有效的利用资源。而这种手段即—— 等待唤醒机制。

 

6.5.2等待唤醒机制所涉及到的方法

wait（） :等待，将正在执行的线程释放其执行资格 和 执行权，并存储到线程池中。

notify（）：唤醒，唤醒线程池中被wait（）的线程，一次唤醒一个，而且是任意的。

notifyAll（）： 唤醒全部：可以将线程池中的所有wait() 线程都唤醒。

 

注意：

1）所谓唤醒的意思就是让 线程池中的线程具备执行资格。必须注意的是，这些方法都是在同步中才有效。

2）同时这些方法在使用时必须标明所属锁（锁对象调用方法），这样才可以明确出这些方法操作的到底是哪个锁上的线程。

 

 

代码示例：

public class Resource {
    public String name; //为了演示方便，设为public
    public int age;
    //添加标记：true赋值完成，false输出完成
    public boolean flag=false; 
}

 

public class Input implements Runnable{    
    private Resource r;
    public Input(){
        
    }
    public Input(Resource r){
        this.r=r;
    }    
    
    //给Resource赋值
    public void run() {    
        int i=0;
        while(true){            
            //添加同步代码块            
            synchronized (r) {
                //判断标记
                if(r.flag){
                    try {
                        r.wait(); //要用锁调用
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                if(i%2==0){ //模拟交替进行，用奇偶数实现
                    r.name="张三";
                    r.age=18;
                }else{
                    r.name="李四";
                    r.age=81;
                }
                r.flag=true; //赋值完成
                r.notify(); //唤醒
            }            
            i++;
        }
    }
}

 

public class Output implements Runnable{    
    private Resource r;
    public Output(){
        
    }
    public Output(Resource r){
        this.r=r;
    }    
    
    //对Resource输出
    public void run() {        
        while(true){            
            //添加同步代码块
            synchronized (r) {
                //判断标记
                if(!r.flag){
                    try {
                        r.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                System.out.println(r.name+"..."+r.age);
                r.flag=false; //输出完成
                r.notify(); //唤醒
            }            
        }
    }
}

 

public class Demo01 {
    public static void main(String[] args) {
        Resource r=new Resource();
        Input in=new Input(r);
        Output out=new Output(r);        
        Thread tin=new Thread(in);
        Thread tout=new Thread(out);
        tin.start();
        tout.start();
    }
}

注意：

1）要共享同一个资源，所以用构造方法，赋同一个对象r

2）Wait()和notify()要放在同步中，要用锁对象调用

3）实现交替进行：

　　用一个标记flag：

　　true：赋值完成

　　false：输出完成

　　Input：如果是true，等待；如果是false，赋值，将flag改为true

　　Output：如果是true，输出，将flag改为false；如果是false，等待

 

 

总结：

线程池：掌握

线程安全：了解

 

转载于:https://www.cnblogs.com/hzhjxx/p/10205953.html

weixin_33815613
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java特别篇-关于线程创建的三种方式的总结对比
02-04
Java特别篇--关于线程创建的三种方式的总结对比
Java线程：线程安全类和Callable与Future(有返回值的线程)
weixin_34378969的博客
12-27 161
一、线程安全类 　　当一个类已经很好的同步以保护它的数据时，这个类就称为线程安全的。当一个集合是安全的，有两个线程在操作同一个集合对象，当第一个线程查询集合非空后，删除集合中所有元素的时候，第二个线程也来执行与第一个线程相同的操作，也许第一个线程查询后，第二个也查出非空，但是此时明显是不对的。如： 1 public class NameList { ...
多线程进阶（Callable接口、JUC、线程安全的集合类以及死锁）
m0_51405559的博客
05-02 388
文章目录一、Callable接口二、JUC的常见类1.Lock系统2.CountDownLatch3.信号量Semaphore4.相关面试题三、线程安全的集合类四、死锁1.什么叫死锁2.如何避免死锁3.如何检测程序是否出现死锁4.如何解决死锁五、web开发中的多线程 一、Callable接口 类似Runnable，用于定义任务的描述接口 但是提供一个返回值，可以用于获取线程执行的结果 例如： int i=0; Thread t = new Thread(new Runnable(){ public vo
多线程进阶（二）Callable接口，JUC下常见类使用及线程安全集合类
小小太空人的博客
01-11 638
这篇文章主要介绍Callable接口，JUC包下一些常见类的使用，还有我们之前使用集合类在多线程环境下的使用。 可以使用Callable接口创建带有返回值的线程任务（和Runable类似）。这样的线程具有返回值，由于线程调度的随机性，我们不确定线程什么时候被调度，具体线程任务什么时候执行完毕。基于这样的问题采取FutureTask类对Callable进行包装。FutureTask就可以等待Callable的执行结果。
记录多线程使用引发的线程安全问题 -- Callable＜T＞ 返回值场景
mufeng
03-11 398
1.场景： 进行多线程处理时，需根据传递的参数，执行相应的方法，并返回结果 代码相关： package cn.sys.Test.thread.callable; import lombok.Getter; import lombok.Setter; import java.util.concurrent.*; class Task implements Callable<String> { private ThreadPoolExecutorTest test; pri
JUC——day02 &&集合的线程安全&& 多线程锁 &&callable接口
weixin_45483328的博客
03-01 389
文章目录1.集合的线程安全问题1.1 List1.1.1 模拟多线程环境1.1.2 原因1.1.3 解决方法1.1.4 写时复制思想1.2 Set1.2.1 解决办法1.2.2 CopyOnWriteArraySet1.3 Map1.3.1 解决方法1.3.2 HashMap，Hashtable和ConcurrentHashMap的区别2.多线程锁2.1 锁对象执行顺序的探究2.2 公平锁和非公平锁2.2.1 定义2.2.2 公平锁2.2.3 非公平锁2.3 可重入锁2.4 死锁3.Callable接口3.
java多线程Future和Callable类示例分享
09-02
JAVA多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。今天我们...
Java期末复习||应用程序设计-多线程和泛型
08-02
Thread、Runnable、Callable 线程操作：isAlive()、isInterrupted()、join()、sleep()、stop()、interrupted()、setDaemon()、setPriority()、yield() 同步与死锁、Object类对线程的支持 泛型、通配符、受限泛型、...
multi-thread:一些多线程的例子
04-01
FirstThread，SecondThread，ThirdThread分别是继承线程，实现Runnable，实现Callable其他的方法 其他的类分别是测试基础方法的线程类，测试内容与名字相关，如TestCurrentThread是测试CurrentThread方法 第2章：...
【多线程高并发编程】三 Callable源码分析
01-20
程序猿学社的GitHub，欢迎Star ...本文已记录到github，形成...源码分析2.1 第一步,实现Callable接口2.2 FutureTask类结构图2.3 RunableFuture接口2.4 Runnable接口2.5 Future接口2.6 FutureTask源码分析后记 前言 通过上
多线程（解决线程安全的3方法,Callable,Lambda）
文雯的博客
02-21 1123
????线程与进程 进程是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间。 线程是进程中的一个执行路径，共享一个内存空间，一个进程最少有一个线程，是对进程进一步划分 ✨当进程里面一个线程都没有时，该进程就被关闭了 例如：一个QQ音乐进程，拥有听歌显示图片刷评论等多个线程 分时调度： 为了能让每个线程均分CPU,一千多个线程快速轮流使用CPU的使用权，交替执行，给人造成一个假象好像多个任务同时在进行一样 Java使用的调度机制——抢占式调度： 哪个线程优先级高就先抢到CPU使用权概率大，优先级可以
02.集合线程不安全问题+Callable接口+JUC下常用三大辅助类
qq_27552845的博客
08-19 243
6.集合线程不安全问题 普通的list在多线程的时候会出现这个异常：java.util.ConcurrentModificationException 并发修改异常！ 6.1List集合的线程不安全解决方案 并发下，list是线程不安全的，但是有三种方式去解决它 1、List list = new Vector<>();//这个是因为add里面有加锁synchronized 2、List list = Collections.synchronizedList(new ArrayList<
Java多线程：Callable接口实现多线程
成龙大侠的博客
11-26 643
在线帮助文档：https://docs.oracle.com/javase/9/docs/api/java/util/concurrent/Callable.html 传统实现多线程一般依靠Runnable，但是Runnable接口有一个缺点：当线程执行完以后无法获取一个返回值。所以从JDK 1.5之后提出了一个新的线程实现接口：java.util.consurrent.Callable接口 ...
多线程进阶JUC之解决线程不安全问题和Callable的使用与注意项
程序彤的博客
02-10 201
解决ArrayList线程不安全 并发下ArrayList线程不安全，解决方法 List<·String> list = new Vector(); List<·String> list = Collections.synchronizedList(new ArrayList<>()) CopyOnWriteArrayList<·String> list = new CopyOnWriteArrayList<>(); Vector synchr
JUC不安全及处理和callable接口
qq_41558341的博客
07-16 119
JUC不安全及处理 证明集合类不安全 举例 错误：java.util.ConcurrentModificationException ArrayList在迭代的时候如果同时对其进行修改就会抛出java.util.ConcurrentModificationException异常 称为“并发修改异常”； 不同线程对同一个list进行操作，又要读又要写。 原理 30个线程对list进行写操作 List<String> list = new ArrayList<>(); for (int
多线程-Callable接口
Ztvue的博客
09-26 160
多线程的开启方式 继承Thread类，实现Runnable接口，实现Callable接口。 前两者是我们常见的多线程实现方式，就不详细介绍了。 实现Callable接口，与前两者不同是带有返回值，在之前的单线程中，如果中间有一个任务需要计算很长时间，那么就可以另开辟一个线程去执行它，最终把结果汇总就可以了，不会阻塞线程。 如下图： Callable实现方式用到了适配器模式。 适配器模式就是让两个没有关系的接口，通过中间类产生关系。 比如： new Thread();我们都知道需要在构造里面传一个Runna
线程及线程安全问题
Striver_111的博客
09-01 177
Java 线程
Java多线程与并发之Callable接口-------是什么，怎么用
atomatom98的博客
10-27 386
面试题：几种方式获得多线程？ 此时如果你答两种：Runnable和继承Thread，这是不行的，正确答案应该是： 传统的是继承thread类和实现runnable接口 JDK1.5 以后又有通过实现callable接口和线程池获得 Callable和Runnable对比 我们都熟悉Runnable接口，只要继承了这个类，并重写其Run方法，就可以通过Thread的构造器传入Runnable实...
Callable接口
qq_42722944的博客
03-27 204
与实现Runable接口相比，Callable功能更强大 原文：http://debuggg.com/article/198 1.与run()方法相比，call()方法可以有返回值 2.call()方法可以抛出异常 3.call()方法支持泛型的返回值 4.call()方法的返回值以及线程的调用需要借助于FutureTask类来实现 示例代码： package com.debugg...
java多线程—Runnable、Thread、Callable区别
最新发布
02-11
Runnable、Thread、Callable是Java中三种不同的多线程实现方式。 Runnable是一个接口，它只有一个run()方法，没有返回值，不能抛出异常。通常需要将它作为参数传递给Thread对象，然后再调用Thread的start()方法来...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值