多线程
- java
java中对于大量的比较耗时的任务多采用多线程对方式对任务进行处理，同时由于进程和线程
本身是通过宿主机OS进行管理的，当在cpu核数较少或线程分配不当 会导致多线程的效果不佳的事常有发生代码片段：
//处理器核心数 int processor = Runtime.getRuntime().availableProcessors(); //XSSFWorkbook 一次只能写入六万多条数据，所以这里最好使用SXSSFWorkbook SXSSFWorkbook workBook = new SXSSFWorkbook(); //创建格式 CellStyle style = workBook.createCellStyle(); //居中格式 style.setAlignment(HorizontalAlignment.CENTER); //手工创建线程池 ExecutorService executorService = new ThreadPoolExecutor(processor, processor, 1000, TimeUnit.MILLISECONDS, new LinkedBlockingDeque(), new ThreadFactoryBuilder().setNameFormat("poi-task-%d").build()); //计数器 等待线程池中的线程执行完毕 CountDownLatch countDownLatch = new CountDownLatch(processor); for (int i = 0; i < processor; i++) { int sheetId = i; //放入线程池中 executorService.execute(() -> createSheet(workBook, style,sheetId, countDownLatch)); } try { //等待所有线程执行完毕 countDownLatch.await(); executorService.shutdown(); } catch (InterruptedException e) { e.printStackTrace(); } go
由于进程和线程都是基于OS管理的，不可避免的产生开销；go区别与以上两者使用的是协程（goroutine），协程是线程的内的细颗粒化，
同时它是被go自己管理的所以开销相当的小，同时一个go应用可以轻松构建上百万个goroutine，不仅如此，go也提供了通道（channel）方便 对协程之间进行数据交互
代码片段：
import ( "fmt" "sync")func says(s string, gw *sync.WaitGroup) { for i := 0; i < 5; i++ { fmt.Println(">>> ", s) } gw.Done()}func main() { var gw sync.WaitGroup gw.Add(1) go says("Hello s", &gw) gw.Wait()} 函数参数传递
- java
java对于函数值对传递采取对是值传递的方式，对于基本数据类型：传递前后值所在栈的位置是不一致的（也就是被拷贝了一份）
对于非基本数据类型：虽然也会做拷贝，但实际上这前后的对象引用的是同一内存位置的值，这就造成了"引用传递的假象"代码片段：
public class TransParams { public static void main(String[] args){ Person p = new Person(); p.setAge(99); p.setName("Lisa"); System.out.println(p.getAge()); System.out.println(p); System.out.println("======>split<====="); TransParams tp = new TransParams(); tp.setValue(p); System.out.println(p.getAge()); System.out.println(p); } public void setValue(Person p){ p.setAge(19); }}class Person { private Integer age; private String name; public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; }} 运行结果:
99 com.task.charset.Person@7e0b37bc ======>split<===== 19 com.task.charset.Person@7e0b37bc
go
go语言的处理方式不同于java，具体分两个种：拷贝传递 和 指针传递
对于拷贝传递：不论是基本数据类型还是结构体类型，前后的值都不会是同一个 对于引用传递：传递前后都是同一个值对象，不会存在java的理解歧义代码片段：
import "fmt"func main() { var s1 []string fmt.Println("拷贝传递前>", s1) tr01(s1) fmt.Println("拷贝传递后>", s1) fmt.Println("=====><=====") var s2 []string fmt.Println("指针传递前>", s2) tr02(&s2) fmt.Println("指针传递后>", s2)}func tr01(m []string) { m = append(m, "youth01")}func tr02(mm *[]string) { *mm = append(*mm, "youth02")} 输出结果：
拷贝传递前> []拷贝传递后> []=====><=====指针传递前> []指针传递后> [youth02]
日期格式处理
- java
在java8之前jdk仅提供了Date类型的格式化，对应的日期处理类是SimpleDateFormat，
在java8至java8之后Oracle提供了LocalDate与LocalDateTime的两种日期格式，对应的日期处理类是DateTimeFormat代码片段：
public class Format2LocalDate { private static final Logger LOG = LoggerFactory.getLogger(Format2LocalDate.class); private static final DateTimeFormatter DATE_FORMAT_SHORT = DateTimeFormatter.ofPattern("yyyyMMdd HH:mm:ss"); @Test public void transDate(){ this.parse(); this.format(); LOG.info("....................."); this.parseD(); this.formatD(); } public void parse(){ String str = "20190116 12:12:22"; Date today = Date.from(LocalDateTime.parse(str,DATE_FORMAT_SHORT).atZone(DateUtil.CHINA_ZONE_ID).toInstant()); LOG.info("转换结果为> {}",today); } public void format(){ LocalDateTime ldt = LocalDateTime.now(); LOG.info("格式化字符串> {}",ldt.format(DATE_FORMAT_SHORT)); } public final static String DATE_FORMAT = "yyyy-MM-dd HH:mm:ss"; public void parseD(){ String dateStr = "2019-01-01 12:22:33"; SimpleDateFormat simpleDateFormat = new SimpleDateFormat(DATE_FORMAT); Date date = null; try { date = simpleDateFormat.parse(dateStr); } catch (ParseException e) { e.printStackTrace(); } LOG.info("转换结果为> {}",date); } public void formatD(){ Date date = new Date(); SimpleDateFormat simpleDateFormat = new SimpleDateFormat(DATE_FORMAT); LOG.info("格式化结果为> {}",simpleDateFormat.format(date)); }} 输出结果为：
转换结果为> Wed Jan 16 12:12:22 CST 2019格式化字符串> 20190313 21:20:23.....................转换结果为> Tue Jan 01 12:22:33 CST 2019格式化结果为> 2019-03-13 21:20:23
go
go的日期处理相对于java来说十分的怪异，官方给出的例子是个固定的日期字符串，并非"yyyymmdd"这种形式，这里就不用说了
看代码代码片段：
/** 官方定义的不可更改*/const DATE_FORMAT string = "2006-01-02 15:04:05"func main() { parse() format()}func parse() { tm := time.Now() strs := tm.Format(DATE_FORMAT) fmt.Println("日期转换为字符串> ", strs)}func format() { tm, _ := time.Parse(DATE_FORMAT, "2019-01-01 12:12:12") fmt.Println("字符串转换为日期> ", tm)} 运行结果：
日期转换为字符串> 2019-03-13 21:29:30字符串转换为日期> 2019-01-01 12:12:12 +0000 UTC
数学运算
java
java的数学基本运算往往会有精度丢失问题，所以对于敏感运算建议使用BigDecimal
代码片段：
//加减乘除都出现了对应的精度问题public class MathCalcul { private static final Logger LOG = LoggerFactory.getLogger(MathCalcul.class); @Test public void calcul(){ LOG.info("加： {}",0.1 + 0.2); LOG.info("减： {}",1.1 - 0.11); LOG.info("乘： {}",1.13 * 100); LOG.info("除： {}",100.13 / 100); }} 输出结果：
加： 0.30000000000000004减： 0.9900000000000001乘： 112.99999999999999除： 1.0012999999999999
go
go 不存在精度丢失问题，可以看代码可知
func main() { fmt.Println("加: ", 0.1+0.2) fmt.Println("减: ", 1.1-0.11) fmt.Println("乘: ", 1.13*100) fmt.Println("除: ", 100.13/100)} 输出结果：
加: 0.3减: 0.99乘: 113除: 1.0013
http Server
java
java的http Server是基于Servlet,应对高并发时的策略是多线程，处理效率一般
代码示例：
class MyServlet extends HttpServlet{ private static final ResourceBundle lStrings = ResourceBundle.getBundle("javax.servlet.http.LocalStrings"); protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { String protocol = req.getProtocol(); String msg = lStrings.getString("http.method_get_not_supported"); if (protocol.endsWith("1.1")) { resp.sendError(405, msg); } else { resp.sendError(400, msg); } } protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { String protocol = req.getProtocol(); String msg = lStrings.getString("http.method_post_not_supported"); if (protocol.endsWith("1.1")) { resp.sendError(405, msg); } else { resp.sendError(400, msg); } }} go
go 源码是自带http包的，所以无需第三方封装，开发较为简单；应对高并发时的策略是多协程，处理效果较好
代码示例：
import ( "fmt" "net/http")func index_handle(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "Whoa,Go is cool!")}func main() { http.HandleFunc("/", index_handle) http.ListenAndServe(":8000", nil)} 常量与静态变量
java
java 中常量(final) 与 静态(static) 是分开的，常量：只能动态赋值一次后不可改变 静态：类型不变
示例：
//静态public static String str = "hello";//常量public final String str2 = "hello2";//不可变量(初始化后不可重新赋值)public static final String str3 = "hello3";
go
go 没有静态一说，只有常量(const)一说，在初始化后不能改变，其实就相当于 java中的 final + static
示例：
const str string = "hello"
__本章就到这里吧，敬请期待下一讲。(^_^)__
现在是 2019-03-13 22:29:50，各位晚安~