Java多线程Java基础相关

线程基础和多线程相关

2020-04-03  本文已影响0人  Sincerity_

基本线程类

1. 继承Thread类

public class MyThread extends Thread {  
　　public void run() {  
　　 System.out.println("MyThread.run()");  
　　}  
}  
MyThread myThread1 = new MyThread();  
MyThread myThread2 = new MyThread();  
myThread1.start();  
myThread2.start();

Thread类本质上是实现Runnable接口的一个实例，代表一个线程的实例。启动线程的唯一方法是通过Thread类的start()实例方法。start()是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。 **多个线程之间无法共享线程类的实例变量 **

2.实现Runnable接口

public class MyThread extends OtherClass implements Runnable {  
　　public void run() {  
　　 System.out.println("MyThread.run()");  
　　}  
} 
MyThread myThread = new MyThread();  
Thread thread = new Thread(myThread);  
thread.start();

3.实现Callable接口通过FutureTask包装器来创建线程

Callable接口提供了一个call()方法可以作为线程执行体，这个方法具有返回值，还可以声明抛出异常

实现Callable接口通过FutureTask包装器来创建Thread线程future模式 并发模式的一种, 可以有二种形式, 无阻赛和阻塞,分别是isDone和get其中future 对象用来存放该线程的返回值以及状态

//Callable接口
public interface Callable<V>   { 
  V call（） throws Exception;  
} 

public class SomeCallable<V> extends OtherClass implements Callable<V> {

    @Override
    public V call() throws Exception {
        // TODO Auto-generated method stub
        return null;
    }
}
Callable<V> oneCallable = new SomeCallable<V>();   
//由Callable<Integer>创建一个FutureTask<Integer>对象：   
FutureTask<V> oneTask = new FutureTask<V>(oneCallable);   
//注释：FutureTask<Integer>是一个包装器，它通过接受Callable<Integer>来创建，
//它同时实现了Future和Runnable接口。 
  //由FutureTask<Integer>创建一个Thread对象：   
Thread oneThread = new Thread(oneTask);   
oneThread.start();   //至此，一个线程就创建完成了

4.使用ExccutorService，Callable，Future实现有返回结果的线程

ExecutorService pool = Executors.newFixedThreadPool(taskSize); 
   for (int i = 0; i < taskSize; i++) {  
    Callable c = new MyCallable();  
    // 执行任务并获取Future对象  
    Future f = pool.submit(c); 
    list.add(f);  
   }  
    // 关闭线程池  
    pool.shutdown();  
    //从Future对象上获取任务的返回值
    f.get()     
   // 获取所有并发任务的运行结果  
//实现Callable接口
class MyCallable implements Callable<Object> {  
public Object call() throws Exception {  
   return null;  
}  

ExecutorService e = Executors.newFixedThreadPool(taskSize); //新建线程池
 //submit方法有多重参数版本，及支持callable也能够支持runnable接口类型.
Future future = e.submit(new myCallable());
future.isDone() //return true,false 无阻塞
future.get() // return 返回值，阻塞直到该线程运行结束

总结 :Runnable，Callable接口与Thread类的对比

synchronized关键字

synchronized关键字用于修饰方法和代码块，以实现同步，当多个线程在执行被synchronized修饰的代码，以排队的方式进行处理。当一个线程调用被修饰的代码时，先判断有没有被上锁，如果上锁就说明有其他线程在调用，必须等待其他线程结束调用后才能执行这段代码，synchronized可以在任意对象以及方法上加锁，加锁的这段代码被称为“互斥区”或者“临界区”

synchronized关键字加到static静态方法是给Class类上锁

synchronized关键字加到非static静态方法上是给对象上锁

关于并行,并发和同步的概念

线程安全

线程的状态

每个对象都有的机制

优雅地停止线程

public class TestThread2_1 {
    public static void main(String[] args) throws InterruptedException {
        MyThreads my = new MyThreads();
        new Thread(my, "线程A").start();
        Thread.sleep(10000);
        //设置标记位
        //my.setFlag(false);

        //stop方法
        new Thread(my, "线程A").stop();
        System.out.println("代码结束");

    }
}

class MyThreads implements Runnable {
    private boolean flag = true;

    @Override
    public void run() {
        int i = 1;
        while (flag) {
            try {
                Thread.sleep(1000);
                System.out.println("第" + i + "次执行，线程名称为：" + Thread.currentThread().getName());
                i++;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

多线程控制类

ThreadLocal类(关于这个类后续会推出关于这个类的专题)

Lock类

Lock lock = new ReentrantLock();
上一篇下一篇

猜你喜欢

热点阅读