在Java的世界中，新开一个线程很容易，你只需要用下面的代码。
1 2 |
Thread thread = new Thread(() -> {while(true) {doSomeThing...}});
thread.run();
|
在深入一点，你应该知道Thread.run()调用了Linux的fork()函数，从父线程中copy出一个一摸一样的子线程，然后开出了一个新的线程。
但是呢？在深入思考一下，提一个问题：
为啥说Go可以随意Goroutine几百几万个？而Java确不建议开那么多的线程，都是建议使用线程池来处理问题？或者说代码里面随意的使用new Thread()可以吗？
答案就是: Go提供的线程是协程是语言层面的，线程切换不必牵涉CPU上下文切换（而且还提供了Forkjoin机制，当有单个协程阻塞，可以分配），Java的线程使用的是Linux的fork()，会涉及CPU上下文切换。
关于协程
关于Go的协程，更加细致的介绍可以看这两篇文章：
https://blog.csdn.net/truexf/article/details/50510073
https://www.jianshu.com/p/533d58970397
可以看到，由于Java的线程切换，涉及从用户态切换到内核态，多了一步操作。如果Java的线程过多就会造成CPU频繁上下文切换，浪费额外时间。所以，开发协程API对于语言来说还是有不小的价值。（是不是觉得Java有点弱，协程都不支持。）
因此在Java世界还是需要合理的使用线程，无论是GC线程还是业务线程。比较经典的例子就是，web服务器的线程池配置。当我们知道Java开了过多的线程之后反而会减低性能，那么我们的web服务器应该如何调优线程池配置？
以NIO模型为例，分为Accept、Selector、还有业务线程，这里的线程池该如何分配呢？
NIO配置: Jetty
全局使用一个线程池QueuedThreadPool,而最小线程数8最大200，Acceptor线程默认1个，Selector线程数默认2个
NIO配置: undertow
undertow 配置的是 Acceptor 递归也就是线程数 1，IO worker是CPU核数，而工作线程数是CPU * 8;
参考：
https://www.cnblogs.com/maybo/p/7784687.html
https://blog.csdn.net/rickiyeat/article/details/78906366
NIO配置: 自己使用Netty来实现
public class NettyHttpController {
public void run() throws InterruptedException {
// accept 线程池，默认为1
EventLoopGroup boss = new NioEventLoopGroup();
// selector 线程池，
EventLoopGroup worker = new NioEventLoopGroup(Integer CPU_Num);
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.group(boss, worker);
bootstrap.channel(NioServerSocketChannel.class);
bootstrap.childHandler(new ChannelInitializer<Channel>() {
@Override
protected void initChannel(Channel channel) throws Exception {
ChannelPipeline channelPipeline = channel.pipeline();
// 业务线程池，伪代码，这里需要开发考虑
channel.add(new Executor(() -> {
doService();
....
channel.respnse("调用成功");
}));
}
});
ChannelFuture channelFuture = bootstrap.bind(9999).sync();
}
public static void main(String[] args) throws InterruptedException {
new NettyHttpController().run();
}
}
线程模型
如果不考虑网络IO等因素，只考虑多线程业务系统的情况，又该如何处理线程池呢？是需要模仿NIO对线程进行分块处理还是怎么样呢？
在代码世界中，如果语言能力比不上人家，那么构建一个好的模型，同样能够击败对手。在《七周七并发》这本书中就推荐了7种并发模型。比较类似的，就是CSP模型（管道模型）和Actor模型，使用Go和Java分别能很好的实现这两者。
CSP模型
-
接收int 数组，并返回一个channel
func gen(nums ...int) <-chan int { out := make(chan int) go func() { for _, n := range nums { out <- n } close(out) }() return out } -
从channel中接收数据，并进行2次方，并放到一个新的channel
func sq(in <-chan int) <-chan int { out := make(chan int) go func() { for n := range in { out <- n * n } close(out) }() return out } -
来看例子一: 如何使用刚刚的两个channel
-
func main() { c := gen(2, 3) // 函数一 out := sq(c) // 函数二 // 消费输出结果 fmt.Println(<-out) // 4 fmt.Println(<-out) // 9 } -
例子二: channel和Actor不同的是，channel关注channel，而不是接收消息的主体。因此，你还可以将一个channel发送给多个函数消费。
func main() { in := gen(2, 3) // 启动两个 sq 实例，即两个goroutines处理 channel "in" 的数据 c1 := sq(in) c2 := sq(in) // merge 函数将 channel c1 和 c2 合并到一起，这段代码会消费 merge 的结果 for n := range merge(c1, c2) { fmt.Println(n) // 打印 4 9, 或 9 4 } }
Actor模型
不同于channel，Actor模型更加类似人类世界的交互模式。任何的交互都是异步的，都需要容忍失败。
public class Hello1 {
public static void main(String[] args) {
ActorSystem system = ActorSystem.create("actor-demo-java");
ActorRef hello = system.actorOf(Props.create(Hello.class));
// 需要定义接收者
hello.tell("Bob", ActorRef.noSender());
// 有一个线程单独处理，都是异步的，需要容忍失败
try {
Thread.sleep(1000);
} catch (InterruptedException e) { /* ignore */ }
system.shutdown();
}
private static class Hello extends UntypedActor {
public void onReceive(Object message) throws Exception {
if (message instanceof String) {
System.out.println("Hello " + message);
}
}
}
}对于我而言，Actor更类似于将消息系统引入到了单机业务中来，他更面向于各种复杂的情况。更类似一个完整的业务情况。
总结
本文从Java线程的实现，到NIO模式线程池配置，再到并发模型，来讲解了如何使用多线程。可以看到一个同步线程是最最简单，但是对于CPU而言，浪费类很多调度时间。如果对业务进行抽象，合理进行建模。无论是针对业务，还是针对系统性能，都能有很大的提升。