# ThreadExample

**Repository Path**: andyfeng/ThreadExample

## Basic Information

- **Project Name**: ThreadExample
- **Description**: java多线程的一些示例
- **Primary Language**: Java
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2016-02-24
- **Last Updated**: 2020-12-19

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

#多线程示例程序，用于理解多线程

##多线程创建的两种方式 (注意两种方式的区别)
1.继承Thread类

````
new Thread(){
            @Override
            public void run() {
                System.out.println("[from Thread]" + Thread.currentThread().getName());
            }
        }.start();
````
2.实现Runnable接口

````
new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("[from Runnable] " + Thread.currentThread().getName());
            }
        }).start();
````

如果一个类即继承了Thread类，又实现了Runnable接口，那么在该类中有就会存在两个run方法，假设为t.run 和 r.run
那么只会调用t.run 方法，只有t.run 方法为空的时候，回去调用Thread.run 方法，此时如果设置了target 即 Runnable线程，
并且该线程不为空，才会调用该Runnable的run 方法

Thread类中run方法的定义，在注释中没有考虑构造方法中传Runnable对象的时候
同时继承Thread覆盖了run方法的情况，如果没有覆盖run方法的话，则执行r.run方法

```
    /**
     * If this thread was constructed using a separate
     * <code>Runnable</code> run object, then that
     * <code>Runnable</code> object's <code>run</code> method is called;
     * otherwise, this method does nothing and returns.
     *
     * Thread的子类必须覆盖此方法
     *
     * @see     #start()
     * @see     #stop()
     * @see     #Thread(ThreadGroup, Runnable, String)
     */
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
```


##定时器
定时器中有两个重要的类

Timer       用来定义调度策略的定时器

    延时执行任务
    public void schedule(TimerTask task,long delay)

    延时执行任务，并且每隔特定时间执行任务
    public void schedule(TimerTask task,long delay,long period)

    在某一时刻执行某一任务
    public void schedule(TimerTask task,Date time)

    在某一时刻执行，并且每个特定时间重复执行此任务
    public void schedule(TimerTask task, Date firstTime, long period)

TimerTask   被调度的任务具体执行的代码逻辑

如在TimerTemplate中，分别定义了4个任务，为每个任务设置一个调度策略

对于后两种具体到某一时间执行的任务，可以构造出一个具体的时间，如下所示
````
        Calendar calendar = Calendar.getInstance();
        calendar.add(calendar.DATE,1);//把日期往后增加一天.整数往后推,负数往前移动
        calendar.set(Calendar.HOUR_OF_DAY, 12); // 控制时
        calendar.set(Calendar.MINUTE, 0);       // 控制分
        calendar.set(Calendar.SECOND, 0);       // 控制秒
        Date date = calendar.getTime();
````

四种调度任务的策略执行方式
````
        new Timer().schedule(timerTask1, 1000);
        //启动之后，延时ss开始执行，在首次执行之后每隔2s执行一次
        new Timer().schedule(timerTask2, 2000, 2000);

        new Timer().schedule( timerTask3 ,date );
        new Timer().schedule( timerTask4 ,date , 2000);
````

通过原生api的方式可以按照一定的频率执行某个任务，但是如果需要按照两个频率执行的话，
则可以通过TimerTestCrossExe的方式，在定时任务中调用定时任务

##线程互斥
线程互斥是指某一资源同时只允许一个访问者对其进行访问，具有唯一性和排它性。
但互斥无法限制访问者对资源的访问顺序，即访问是无序的。
关键字：synchronized
该关键字可以用来修饰方法或者是某一个属性，相当于对被修饰的对象加一个锁

其他的访问者想要获得就必须要等待锁被释放。
在类ThreadSynchronized中列出了几种不加锁以及加锁的方法

对于用static修饰的synchronized方法来说，如果想要与其互斥访问同一资源，
则可以在其所在的类上添加锁及 ThreadSynchronized.class
例如 outputStaticFun 和 outputWithStaticSyn 两个方法就可以互斥的访问同一资源


##线程同步通信


##线程范围内共享变量

##ThreadLocal类及其应用

##多个线程之间共享数据的方式

##原子性操作类的应用

##线程并发库

##Callable与Future的应用

##线程锁

##读写锁

##条件阻塞Condition的应用

##同步工具
Semaphere

CyclicBarrier

CountDownloadLatch

Exchanger

##阻塞队列

##同步集合类的应用