juc并发编程学习(一)

• 1.新建一个maven项目

pom.xml配置

 <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.11</version>
        </dependency>
    </dependencies>

在resources.xml配置

<?xml version="1.0" encoding="UTF-8" ?>
<configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <!-- encoders are assigned the type
             ch.qos.logback.classic.encoder.PatternLayoutEncoder by default -->
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    <root level="debug">
        <appender-ref ref="STDOUT" />
    </root>
</configuration>

2.概念：

进程：
（1)程序由指令和数据组成，但是这些程序要运行，数据要读写，就必须将指令加载到cpu，数据加载至内存，在指令运行过程之中还需要用到磁盘，网络设备等，进程就是来加载指令,管理内存,管理io
(2)当一个程序要运行，从磁盘加载这个程序至内存，这时候就开启了一个程序
（3）进程就可以视为一个实例，大部分程序可以同时运行多个进程，也可以启动一个进程实例
线程
（1）一个进程可以分为一个或多个线程
（2）一个线程就是一个指令流，将指令流按顺序一条条交给cpu执行
（3）在java之中，线程作为最小的调度单位，进程作为分配资源最小的单位，在windows之中进程是不活动的，只是作为线程的容器

二者对比
（1）进程是相互独立的，而线程存在进程内，是进程的一个子集
（2）进程拥有共享资源，如内存空间，供内部线程共享
进程之间的通讯：
（1）同一台计算机之间的进程通信称为：IPC
（2）不同计算机之间的进程通信，需要通过网络，并遵循共同的协议，例如http
（3）线程通信相对简单，因为它们共享进程内存，多个线程可以访问一个共享变量
（4）线程更轻量，线程上下文切换成本一般比进程上下文切换低。

并发：同一个时间应对多件事的能力
并行：同一个时间做多件事的能力

同步和异步调用：
（1）需要等待结果返回，才能运行的就是同步
（2）不需要等待结果返回，能继续运行的叫异步
同步在多线程之中，就是让多个线程步调一致

• 3.创建线程的方法

(1.)使用thread

package juc;

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "juc.test")
public class test {
    public static void main(String[] args) {
        
        Thread t=new Thread(){
            @Override
            public void run(){
                log.debug("runging");
            }
        };
        t.setName("t1");
        t.start();
        log.debug("running");
    }
}

运行结果

18:06:54.112 [main] DEBUG juc.test - running
18:06:54.114 [t1] DEBUG juc.test - runging

(2)Runnable
源码：

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

只有一个抽象方法，在jdk之中如果带有@FunctionalInterface这个注解就可以被lamnda简化
在Thread implements Runnable
Runnable更容易与线程池这种高级api结合在一起
用Runnable让任务脱离了Thead这种继承体系
（3） Callable
源码

@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

有返回值，并且能抛出异常
例子·：

package juc;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

@Slf4j(topic = "juc.test2")
public class Test2 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        FutureTask<Integer> integerFutureTask = new FutureTask<Integer>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                log.debug("runing");
                Thread.sleep(1000);
                return 1000;
            }
        });

        Thread thread = new Thread(integerFutureTask,"t1");
        thread.start();

        log.debug("{}",integerFutureTask.get());


    }
}

结果

19:11:52.852 [t1] DEBUG juc.test2 - runing
19:11:53.867 [main] DEBUG juc.test2 - 1000

Process finished with exit code 0

线程阻塞1秒才获取结果 52秒 …53秒