java并发编程之初识线程

最新推荐文章于 2021-02-12 18:03:32 发布

qq_37556726

最新推荐文章于 2021-02-12 18:03:32 发布

阅读量940

点赞数

分类专栏： java并发编程之初识线程文章标签： java并发编程之初识线程

本文链接：https://blog.csdn.net/qq_37556726/article/details/98678330

版权

java并发编程之初识线程专栏收录该内容

1 篇文章 0 订阅

订阅专栏

java并发编程之初识线程

说明

说明

操作系统运行一个程序就会创建一个进程，例如我们一个main函数程序启动了，就会创建一个java进程，然后有一个main主线程和其他线程（至少一个垃圾回收线程），这时我们如果想java做的任务更多时间更少就可以创建更多线程，这样能够最大化利用cpu,更快响应。

线程生命周期

在这里插入图片描述

线程创建

继承Thread类创建线程

代码实例

public class MyThread extends Thread{//继承Thread类

　　public void run(){

　　//重写run方法

　　}

}

public class Main {

　　public static void main(String[] args){

　　　　new MyThread().start();//创建并启动线程

　　}

}

实现Runnable接口创建线程

public class MyThread2 implements Runnable {//实现Runnable接口

　　public void run(){

　　//重写run方法

　　}

}

public class Main {

　　public static void main(String[] args){

　　　　//创建并启动线程

　　　　MyThread2 myThread=new MyThread2();

　　　　Thread thread=new Thread(myThread);

　　　　thread().start();

　　　　//或者    new Thread(new MyThread2()).start();

　　}

}

使用Callable和Future创建线程

       FutureTask<Integer> futureTask = new FutureTask(()->7);

        new Thread(futureTask).start();
        try {
            futureTask.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

使用线程池例如用Executor框架

   Executor框架包括：线程池，Executor，Executors，ExecutorService，
   CompletionService，Future，Callable等。

Executor执行Runnable任务
public class TestCachedThreadPool{   
    public static void main(String[] args){   
        ExecutorService executorService = Executors.newCachedThreadPool();   
//      ExecutorService executorService = Executors.newFixedThreadPool(5);  
//      ExecutorService executorService = Executors.newSingleThreadExecutor();  
 //       ScheduledExecutorService executorService = Executors.newScheduledThreadPool(2);

        for (int i = 0; i < 5; i++){   
            executorService.execute(new TestRunnable());   
            System.out.println("************* a" + i + " *************");   
        }   
        executorService.shutdown();   
    }   
}   
  
class TestRunnable implements Runnable{   
    public void run(){   
        System.out.println(Thread.currentThread().getName() + "线程被调用了。");   
    }   
} 
Executor执行Callable任务
public class CallableDemo{   
    public static void main(String[] args){   
        ExecutorService executorService = Executors.newCachedThreadPool();   
        List<Future<String>> resultList = new ArrayList<Future<String>>();   
  
        //创建10个任务并执行   
        for (int i = 0; i < 10; i++){   
            //使用ExecutorService执行Callable类型的任务，并将结果保存在future变量中   
            Future<String> future = executorService.submit(new TaskWithResult(i));   
            //将任务执行结果存储到List中   
            resultList.add(future);   
        }   
  
        //遍历任务的结果   
        for (Future<String> fs : resultList){   
                try{   
                    while(!fs.isDone);//Future返回如果没有完成，则一直循环等待，直到Future返回完成  
                    System.out.println(fs.get());     //打印各个线程（任务）执行的结果   
                }catch(InterruptedException e){   
                    e.printStackTrace();   
                }catch(ExecutionException e){   
                    e.printStackTrace();   
                }finally{   
                    //启动一次顺序关闭，执行以前提交的任务，但不接受新任务  
                    executorService.shutdown();   
                }   
        }   
    }   
}   
  
  
class TaskWithResult implements Callable<String>{   
    private int id;   
  
    public TaskWithResult(int id){   
        this.id = id;   
    }   
  
    /**  
     * 任务的具体过程，一旦任务传给ExecutorService的submit方法， 
     * 则该方法自动在一个线程上执行 
     */   
    public String call() throws Exception {  
        System.out.println("call()方法被自动调用！！！    " + Thread.currentThread().getName());   
        //该返回结果将被Future的get方法得到  
        return "call()方法被自动调用，任务返回的结果是：" + id + "    " + Thread.currentThread().getName();   
    }   
}
/** * <三> 使用ExecutorCompletionService管理异步任务 * 
 * 1. Java中的ExecutorCompletionService<V>本身有管理任务队列的功能 
 * i. ExecutorCompletionService内部维护列一个队列, 用于管理已完成的任务 
 * ii. 内部还维护列一个Executor, 可以执行任务 
 * 2. ExecutorCompletionService内部维护了一个BlockingQueue, 只有完成的任务才被加入到队列中 
 * 3. 任务一完成就加入到内置管理队列中, 如果队列中的数据为空时, 调用take()就会阻塞 (等待任务完成) * i. 关于完成任务是如何加入到完成队列中的, 请参考ExecutorCompletionService的内部类QueueingFuture的done()方法 
 * 4. ExecutorCompletionService的take/poll方法是对BlockingQueue对应的方法的封装, 关于BlockingQueue的take/poll方法: 
 * i. take()方法, 如果队列中有数据, 就返回数据, 否则就一直阻塞; 
 * ii. poll()方法: 如果有值就返回, 否则返回null * iii. poll(long timeout, TimeUnit unit)方法: 如果有值就返回, 否则等待指定的时间; 如果时间到了如果有值, 就返回值, 否则返回null
 * 解决了已完成任务得不到及时处理的问题 */
 ExecutorCompletionService<Integer> executorCompletionService = new ExecutorCompletionService<Integer>(Executors.newSingleThreadExecutor());
        executorCompletionService.submit(()->7);
        try {
            Future<Integer> take = executorCompletionService.take();
            Integer integer = take.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

线程间通信

　　Java中线程通信协作的最常见的两种方式：

　　一.syncrhoized加锁的线程的Object类的wait()/notify()/notifyAll()

　　二.ReentrantLock类加锁的线程的Condition类的await()/signal()/signalAll()

　　线程间直接的数据交换：

　　三.通过管道进行线程间通信：1）字节流；2）字符流

线程池

        ExecutorService executorService = Executors.newCachedThreadPool();   
//      ExecutorService executorService = Executors.newFixedThreadPool(5);  
//      ExecutorService executorService = Executors.newSingleThreadExecutor();  
 //       ScheduledExecutorService executorService = Executors.newScheduledThreadPool(2);
         BlockingQueue<Runnable> blockingQueue= new ArrayBlockingQueue<Runnable>(10);
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(4, 5, 60,    TimeUnit.SECONDS,blockingQueue);
        threadPoolExecutor.execute();

生产者消费者实例

package com.jp.oneone;

public class ValueObject {

    public static String value = "";

}
package com.jp.oneone;

//生产者
public class P extends Thread{

    private String lock;

    public P(String lock) {
        super();
        this.lock = lock;
    }
    
    @Override
    public void run() {
        while (true) {
            try {
                synchronized (lock) { //当前线程必须获得锁才可以进行下面的操作
                    if (!ValueObject.value.equals("")) {//如果Value不为空，说明字符串还没被消费，所以调用wait方法，把当前线程（生成线程）阻塞
                        lock.wait();
                    }
                    String value = System.currentTimeMillis() + "_"
                            + System.nanoTime();
                    System.out.println("set的值是" + value);
                    ValueObject.value = value;//为空的话，则生成
                    lock.notify();//生成完就唤醒等待该对象锁的线程，（这里只有一个消费者等这个锁，所以就是唤醒的它）
                }

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

package com.jp.oneone;

//消费者
public class C extends Thread {

    private String lock;

    public C(String lock) {
        super();
        this.lock = lock;
    }
    
    @Override
    public void run() {
        while (true) {
            try {
                synchronized (lock) {
                    if (ValueObject.value.equals("")) {//如果字符串为空，即被消费完了，所以wait等待。
                        lock.wait();
                    }
                    System.out.println("get的值是" + ValueObject.value);
                    ValueObject.value = "";
                    lock.notify();
                }

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
package com.jp.oneone;

public class Run {

    public static void main(String[] args) {

        String lock = new String("");
        P p = new P(lock);
        C r = new C(lock);

        p.start();
        r.start();
    }

}



再来一版
package oneone;

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

public class MyService {

    private ReentrantLock lock = new ReentrantLock();//拿到可重入锁，相当于synchronized的作用
    private Condition condition = lock.newCondition();//调用await和signal方法的对象，相当于Object对象（任意对象）的的wait和notify方法
    private boolean hasValue = false;

    //生产者
    public void set() {
        try {
            lock.lock();//获得锁
            while (hasValue == true) {
                condition.await(); //没被消费则阻塞该生产线程，当然也释放了锁，进入等锁的队列
            }
            System.out.println("打印★");
            hasValue = true;
            condition.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    
    //消费者
    public void get() {
        try {
            lock.lock();
            while (hasValue == false) {
                condition.await();
            }
            System.out.println("打印☆");
            hasValue = false;
            condition.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

package oneone;

public class MyThreadA extends Thread {

    private MyService myService;

    public MyThreadA(MyService myService) {
        super();
        this.myService = myService;
    }

    @Override
    public void run() {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            myService.set();
        }
    }

}


package oneone;


public class MyThreadB extends Thread {

    private MyService myService;

    public MyThreadB(MyService myService) {
        super();
        this.myService = myService;
    }

    @Override
    public void run() {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            myService.get();
        }
    }

}
package oneone;

public class Run {

    public static void main(String[] args) throws InterruptedException {
        MyService myService = new MyService();

        MyThreadA a = new MyThreadA(myService);
        a.start();

        MyThreadB b = new MyThreadB(myService);
        b.start();

    }
}

多线程买票案例

class Xc implements Runnable{
	public static int chepiao = 100;
	//synchronized的作用是，让它所管辖的代码部分，要么全部执行完，要么全部不执行，synchronized既可修饰代码块，又可以修饰函数
//	如果是锁整个方法，可以在方法内加锁，表达上比如public synchronized void run(){，但对于此案例，是两个线程之间竞争售票，因此不适宜锁起来整个方法
	//如果synchronized是锁起来整个方法的，synchronized修饰函数不需要传入字符串参数，相当于默认是this
	public void run(){
		while (true) {
			synchronized (" ") {//在需要加锁保证完整运行的代码块旁边加上synchronized (" "){}包裹代码，即可锁起来该部分代码，()内的字符串随意定义
				if(chepiao>0){
					System.out.println("第" + Thread.currentThread().getName() + "个车站正在卖出第" + (101-chepiao) + "张车票");
					--chepiao;
				}else{
					break;
				}
			}
		}
	}
}
public class XianCheng {
	public static void main(String [] args){
		Thread Xc1 = new Thread(new Xc());//模拟两个车站在卖车票，竞争共同的线程资源
		Xc1.start();
		Thread Xc2 = new Thread(new Xc());//模拟两个车站在卖车票，竞争共同的线程资源
		Xc2.start();
	}
}

多线程切换等待唤醒交替打印奇偶数

package com.svse.thread;
import java.util.concurrent.atomic.AtomicInteger;
/**
 * 交替打印奇偶数
 *功能说明:
 *@author:zsq
 *create date:2019年5月27日 下午4:34:30
 *修改人   修改时间  修改描述
 *
 *Copyright (c)2019北京智华天成科技有限公司-版权所有
 */
public class AlternatePrinting {
	　　//让两个线程使用同一把锁。交替执行 。
	　　//判断是不是奇数 如果是奇数进入奇数线程执行打印并加一。然后线程释放锁资源。然后让该线程等待
	　　//判断是不是偶数，如果是偶数进入偶数线程执行打印并加一。然后线程释放锁资源。然后让该线程等待
	　　public static AtomicInteger atomicInteger =new AtomicInteger(1);
	
	　　public static void main(String[] args) {
		　　　　Thread a=new Thread(new AThread());
		　　　　Thread b=new Thread(new BThread());
		　　　　a.start();
		　　　　b.start();
	　　}
	
	
	　　//奇数线程
	　　public static class AThread implements Runnable{
	        　　　　public void run() {
	           　　　　　　while(true){
	        	   　　　　　　　　synchronized (atomicInteger) {
					　　　　　　　　if(atomicInteger.intValue()%2 !=0){
						　　　　　　　　　　System.out.println("奇数线程:" + atomicInteger.intValue());
						　　　　　　　　　　try {
							　　　　　　　　　　　　Thread.sleep(500);
						　　　　　　　　　　} catch (InterruptedException e1) {
							　　　　　　　　　　　　// TODO Auto-generated catch block
							　　　　　　　　　　　　e1.printStackTrace();
						　　　　　　　　　　}
						　　　　　　　　　　atomicInteger.getAndIncrement(); // 以原子方式将当前值加 1。
						　　　　　　　　　　// 奇数线程释放锁资源
						　　　　　　　　　　atomicInteger.notify();//执行完操作后释放锁并进入等待
						　　　　　　　　　　try {
							　　　　　　　　　　　　atomicInteger.wait();
						　　　　　　　　　　} catch (InterruptedException e) {
							　　　　　　　　　　　　e.printStackTrace();
						　　　　　　　　　　}
					　　　　　　　　}else{
						　　　　　　　　　　// 奇数线程等待
						　　　　　　　　　　try {
							　　　　　　　　　　　　atomicInteger.wait();
						　　　　　　　　　　} catch (InterruptedException e) {
							　　　　　　　　　　　　// TODO Auto-generated catch block
							　　　　　　　　　　　　e.printStackTrace();
						　　　　　　　　　　}
					　　　　　　　　}
				　　　　　　}
	           　　　　 }
	        　　　　}
	　　}
 
	　　 //偶数线程
	　　public static class BThread implements Runnable{
		　　　　public void run() {
			　　　　　　while(true){
				　　　　　　　synchronized (atomicInteger) {
					　　　　　　　if(atomicInteger.intValue()%2 ==0){
						 　　　　　　　　　　System.out.println("偶数线程:"+ atomicInteger.intValue());
						 　　　　　　　　　　try {
								　　　　　　　　　　　　Thread.sleep(500);
							　　　　　　　　　　} catch (InterruptedException e1) {
								　　　　　　　　　　　　// TODO Auto-generated catch block
								　　　　　　　　　　　　e1.printStackTrace();
							　　　　　　　　　　}
						 　　　　　　　　atomicInteger.getAndIncrement(); // 以原子方式将当前值加 1。
						 　　　　　　　　// 偶数线程释放锁资源
						 　　　　　　　　atomicInteger.notify();//执行完操作后释放锁并进入等待
						 　　　　　　　　try {
							　　　　　　　　　　atomicInteger.wait();
						　　　　　　　　} catch (InterruptedException e) {
							　　　　　　　　　　e.printStackTrace();
						　　　　　　　　}
					　　　　　　}else{
						　　　　　　　　try { 
							 　　　　　　　　　　// 偶数线程等待
							　　　　　　　　　　atomicInteger.wait();
						　　　　　　　　} catch (InterruptedException e) {
							　　　　　　　　　　// TODO Auto-generated catch block
							　　　　　　　　　　e.printStackTrace();
						　　　　　　　　}
					　　　　　　 }
				　　　  　}
			　　　　}
    }
  }
}