线程-Thread

蔚落 2021-12-22 02:49 301阅读 0赞

## 线程 ##

线程和进程的区别：

①线程是程序中一个单一的顺序控制流程。进程内一个相对独立的、可调度的执行单元，是系统独立调度和分派CPU的基本单位指运行中的程序的调度单位。

在单个程序中同时运行多个线程完成不同的工作，称为多线程。

②进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础

进程和线程的关系：

![1700523-20190613104751017-1716058620.png][]

并发和并行：

并行：多个线程可以同时执行，每一个时间段，可以有多个线程同时执行。

![1700523-20190613105408131-1721017423.png][]

并发：多个线程同时竞争一个位置，竞争到的才可以执行，每一个时间段只有一个线程在执行。

![1700523-20190613105428996-34462648.png][]

线程的4种创建方式：

1.继承Thread类创建线程

2.实现Runnable接口创建线程

3.使用Callable和Future创建线程

4.使用线程池例如用Executor框架

**一，继承Thread类创建线程**

public class ThreadTest extends Thread{
        
        public void run(){
            for(int i=1;i<=20;i++){
                System.out.println(i+".你好，来自线程"+Thread.currentThread().getName());
            }
        }
    }

测试类及运行结果：

public class TestCase {    
        public static void main(String[] args) {
            ThreadTest one=new ThreadTest();
            ThreadTest one1=new ThreadTest();
            one.start();
            one1.start();
        }
    }

![1700523-20190614175905848-508908321.png][]

**2.实现Runnable接口创建线程**

public class RunnableTest implements Runnable{
        @Override
        public void run() {
            for(int i=1;i<=20;i++){
                System.out.println(i+".你好，来自线程"+Thread.currentThread().getName());
            }        
        }
    }

测试类及运行结果：

public class TestRunnable {    
        public static void main(String[] args) {
            RunnableTest rt=new RunnableTest();
            Thread t1=new Thread(rt);
            Thread t2=new Thread(rt);
            t1.start();
            t2.start();
        }
    }

![1700523-20190614180133492-1515442851.png][]

**3.使用Callable和Future创建线程**

public class CallAbleTest implements Callable<String>{
        @Override
        //拥有返回值和可以抛异常的方法体
        public String call() throws Exception {
            System.out.println("call的名字："+Thread.currentThread().getName());
            return "我是call";
        }
    }

测试类和运行结果：

public class TestCall614 {    
        public static void main(String[] args) {
            //创建FutureTask对象来包装CallAbleTest
            FutureTask<String> ft=new FutureTask<String>(new CallAbleTest());
            //创建线程对象
            Thread th=new Thread(ft,"CallAble");
            th.start();
            try {
                //打印返回值信息
                System.out.print(ft.get());
            } catch (Exception e) {
                
                e.printStackTrace();
            }        
        }
    }

![1700523-20190614180744171-1477358173.png][]

**4.使用线程池例如用Executor框架**

public class ThreadPoolTest {    
        public static void main(String[] args) {
            //创建一个具有10条线程的线程池
            ExecutorService exs=Executors.newFixedThreadPool(10);
            for(int i=0;i<10;i++){
                //匿名内部类来重写run函数,来创建十个线程            
                exs.execute(new Runnable(){
                    public void run(){
                        System.out.println("线程名为："+Thread.currentThread().getName());
                    }
                });
            }
            //关闭线程池
            exs.shutdown();

运行结果：

![1700523-20190614181231585-1054929940.png][]

**ThreadPoolExecutor**的参数详解：

![1700523-20190614182143719-953018147.png][]

ThreadPoolExecutor的创建：

//尽量保证:任务数不要超过最大线程数+阻塞队列的长度
            ThreadPoolExecutor tp=new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,  new LinkedBlockingQueue<Runnable>(10));
            for(int i=0;i<20;i++){
                tp.execute(new Runnable(){
                    @Override
                    public void run() {
                        System.out.println("线程名为："+Thread.currentThread().getName());
                        try {
                            Thread.sleep(1500);
                        } catch (InterruptedException e) {                        
                            e.printStackTrace();
                        }                    
                    }                
                });
            }
            tp.shutdown();
        }

两个例子：

**第一个例子，两个线程交替循环多次：**

public class FatherAndSon {
        boolean flag=true;
        public void son(){            
            synchronized (this) {    
                if(!flag){
                    try {
                        this.wait();
                    } catch (Exception e) {                
                        e.printStackTrace();
                    }
                }
                for(int i=1;i<=3;i++){
                    System.out.println("儿子线程"+i);
                }
                flag=false;
                this.notify();
            }        
        }
        public void father(){        
            synchronized (this) {    
                if(flag){
                    try {
                        this.wait();
                    } catch (Exception e) {                
                        e.printStackTrace();
                    }
                }
                for(int i=1;i<=5;i++){
                    System.out.println("父线程"+i);
                }
                flag=true;
                this.notify();
            }
        }
    }

测试类及其结果：

public class TestFather {    
        public static void main(String[] args) {
            final FatherAndSon fa=new FatherAndSon();
            Thread th=new Thread(new Runnable(){
                @Override
                public void run() {    
                    for(int i=0;i<10;i++){
                        fa.son();
                    }                
                }            
            });
            th.start();        
            for(int i=0;i<10;i++){
                fa.father();
            }
        }
    }

![1700523-20190614183945296-965227190.png][]

**第二个例子：循环打印三个汉字**

public class PrintlnWorlds implements Runnable{
        private String worlds;//要打印的字符
        private Object previous;//上一个对象
        private Object current;//当前对象    
        public PrintlnWorlds(String worlds,Object previous,Object current){
            super();
            this.worlds=worlds;
            this.previous=previous;
            this.current=current;
        }        
        @Override
        public void run() {
            for(int i=0;i<10;i++){
            synchronized (previous) {
                synchronized (current) {    
                    current.notify();
                    System.out.print(worlds);                                
                }
                try {
                    previous.wait();
                } catch (Exception e) {                
                    e.printStackTrace();
                }
            }        
            }        
        }
    }

测试类及运行结果：

public class TestPrintln {    
        public static void main(String[] args) {
            Object a=new Object();
            Object b=new Object();
            Object c =new Object();        
            PrintlnWorlds p1=new PrintlnWorlds("我",c,a);
            PrintlnWorlds p2=new PrintlnWorlds("爱",a,b);
            PrintlnWorlds p3=new PrintlnWorlds("你",b,c);
            Thread t1=new Thread(p1);
            Thread t2=new Thread(p2);
            Thread t3=new Thread(p3);        
            t1.start();        
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {            
                e.printStackTrace();
            }
            t2.start();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {            
                e.printStackTrace();
            }
            t3.start();        
        }
    }

![1700523-20190614184802568-1058962986.png][]

转载于:https://www.cnblogs.com/TFE-HardView/p/11014902.html

[1700523-20190613104751017-1716058620.png]: /images/20211220/cf7b1665212c4183ba79aa99dcff9554.png
[1700523-20190613105408131-1721017423.png]: /images/20211220/358cd0429905427a8d536ebdcdd204b7.png
[1700523-20190613105428996-34462648.png]: /images/20211220/5fe8c82066ea4994a25db34f778debad.png
[1700523-20190614175905848-508908321.png]: /images/20211220/f2a60bf7f9be4a4799ffc54cae93b51d.png
[1700523-20190614180133492-1515442851.png]: /images/20211220/56a9ef37adf840dea134f80655c9db0e.png
[1700523-20190614180744171-1477358173.png]: /images/20211220/3348ff32b0854c078524ad929238461d.png
[1700523-20190614181231585-1054929940.png]: /images/20211220/23269b67242a4505ac8ccd65d14be7f1.png
[1700523-20190614182143719-953018147.png]: /images/20211220/d713a74e0984443ab82c994a3cab950a.png
[1700523-20190614183945296-965227190.png]: /images/20211220/d1bdcd06321140eab6cb4186d3056d24.png
[1700523-20190614184802568-1058962986.png]: /images/20211220/c8e19a4720e5467ebad389c8ee7bb697.png