itgoyo'blogTalk is cheap,Show me the girl.2020-01-02T05:53:54.669Zhttps://itgoyo.github.io/itgoyoHexo2019一整年的总结与一些个人反思https://itgoyo.github.io/2020/11/29/2019一整年的总结与一些个人反思/2020-11-29T02:33:05.000Z2020-01-02T05:53:54.669Z
public static void main(String ards[]){ Runnable implRunnable = new ImplRunnable(); for(int i=0;i<10;i++){ new Thread(implRunnable).start(); } System.out.println(Thread.currentThread().getName()); }
}
class ImplRunnable implements Runnable{ private volatile int i = 0; @Override public void run() { System.out.println(Thread.currentThread().getName()+"--"+ i++);
} }
3. 实现 Callable 接口，重写 call 方法（有返回值）
自定义类实现 Callable 接口时，必须指定泛型，该泛型即返回值的类型
每次创建一个新的线程，都要创建一个新的 Callable 接口的实现类、
如何启动线程？
（1）创建一个 Callable 接口的实现类的对象
（2）创建一个 FutureTask 对象，传入 Callable 类型的参数
public FutureTask(Callable callable){……}
（3）调用 Thread 类重载的参数为 Runnable 的构造器创建 Thread 对象
将 FutureTask 作为参数传递
public class FutureTask implements RunnableFuture
public interface RunnableFuture extends Runnable, Future
You will also need to install all the necessary binaries. vim-go makes it easy to install all of them by providing a command, :GoInstallBinaries, which will go get all the required binaries.
func main() { fmt.Println("My favorite number is", rand.Intn(10)) }
然后在Vim下面执行:Go Run即可输出
1
My favorite number is 1
项目二 Imports
1 2 3 4 5 6 7 8 9 10
package main
import ( "fmt" "math" )
func main() { fmt.Printf("Now you have %g problems.\n", math.Sqrt(7)) }
输出
1
Now you have 2.6457513110645907 problems.
项目三 Exported names
In Go, a name is exported if it begins with a capital letter. For example, Pizza is an exported name, as is Pi, which is exported from the math package.
pizza and pi do not start with a capital letter, so they are not exported.
When importing a package, you can refer only to its exported names. Any “unexported” names are not accessible from outside the package.
Run the code. Notice the error message.
To fix the error, rename math.pi to math.Pi and try it again.
1 2 3 4 5 6 7 8 9 10
package main
import ( "fmt" "math" )
func main() { fmt.Println(math.pi) }
输出
1
3.141592653589793
项目四 Functions
A function can take zero or more arguments.
In this example, add takes two parameters of type int.
Notice that the type comes after the variable name.
rune // alias for int32 // represents a Unicode code point
float32 float64
complex64 complex128
The example shows variables of several types, and also that variable declarations may be “factored” into blocks, as with import statements.
The int, uint, and uintptr types are usually 32 bits wide on 32-bit systems and 64 bits wide on 64-bit systems. When you need an integer value you should use int unless you have a specific reason to use a sized or unsigned integer type.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
package main
import ( "fmt" "math/cmplx" )
var ( ToBe bool = false MaxInt uint64 = 1<<64 - 1 z complex128 = cmplx.Sqrt(-5 + 12i) )
Variables declared without an explicit initial value are given their zero value.
The zero value is:
0 for numeric types,
false for the boolean type, and
"" (the empty string) for strings.
1 2 3 4 5 6 7 8 9 10 11
package main
import "fmt"
func main() { var i int var f float64 var b bool var s string fmt.Printf("%v %v %v %q\n", i, f, b, s) }
输出
1
0 0 false ""
项目十三 Type conversions
The expression T(v) converts the value v to the type T.
Some numeric conversions:
var i int = 42 var f float64 = float64(i) var u uint = uint(f)
Or, put more simply:
i := 42 f := float64(i) u := uint(f)
Unlike in C, in Go assignment between items of different type requires an explicit conversion. Try removing the float64 or uint conversions in the example and see what happens.
1 2 3 4 5 6 7 8 9 10 11 12 13
package main
import ( "fmt" "math" )
func main() { var x, y int = 3, 4 var f float64 = math.Sqrt(float64(x*x + y*y)) var z uint = uint(f) fmt.Println(x, y, z) }
输出
1
3 4 5
项目十四 Type inference
When declaring a variable without specifying an explicit type (either by using the := syntax or var = expression syntax), the variable’s type is inferred from the value on the right hand side.
When the right hand side of the declaration is typed, the new variable is of that same type:
var i int j := i // j is an int
But when the right hand side contains an untyped numeric constant, the new variable may be an int, float64, or complex128 depending on the precision of the constant:
i := 42 // int f := 3.142 // float64 g := 0.867 + 0.5i // complex128
Try changing the initial value of v in the example code and observe how its type is affected.
1 2 3 4 5 6 7 8
package main
import "fmt"
func main() { v := 42 // change me! fmt.Printf("v is of type %T\n", v) }
输出
1
v is of type int
项目十五 Constants
Constants are declared like variables, but with the const keyword.
Constants can be character, string, boolean, or numeric values.
const ( // Create a huge number by shifting a 1 bit left 100 places. // In other words, the binary number that is 1 followed by 100 zeroes. Big = 1 << 100 // Shift it right again 99 places, so we end up with 1<<1, or 2. Small = Big >> 99 )
func needInt(x int) int { return x*10 + 1 } func needFloat(x float64) float64 { return x * 0.1 }
中间使用命令的过程中可能会出现没有权限的提示xxx is not in the sudoers file. This incident will be reported 的错误，解决方法就是在/etc/sudoers文件里给用户添加权限，此时如果我们直接输入命令chmod u+w /etc/sudoers 会报错如下：
这是因为动态数组支持 resize 操作，可以增加数组的容量。当一个大小为 N 的列表第一次需要添加数据时，Python 会创建一个新的列表，足够放原来的 N 个元素以及额外添加的元素。不过，实际分配的并不是 N+1 个元素，而是 M 个元素，M > N, 这是为了给未来的添加预留空间。然后旧列表的数据被复制到新列表中，旧列表则会被销毁。从设计理念上来说，第一次添加可能是后续多次添加的开始，通过预留空间的做法，我们就可以减少这一分配空间的操作次数以及内存复制的次数。这点非常重要，因为内存复制可能非常的昂贵，特别是当列表大小开始增长以后。
>>> t = (1, 2, 3, 4) >>> t[0] = 5 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'tuple' object does not support item assignment
Python 2.0 - October 16, 2000，加入了内存回收机制，构成了现在 Python 语言框架的基础
Python 2.4 - November 30, 2004, 同年目前最流行的 WEB 框架 Django 诞生
Python 2.5 - September 19, 2006
Python 2.6 - October 1, 2008
Python 2.7 - July 3, 2010
In November 2014, it was announced that Python 2.7 would be supported until 2020, and reaffirmed that there would be no 2.8 release as users were expected to move to Python 3.4+ as soon as possible
线程不能利用多 CPU 问题，这是 Python 被人诟病最多的一个缺点，GIL 即全局解释器锁（Global Interpreter Lock），是计算机程序设计语言解释器用于同步线程的工具，使得任何时刻仅有一个线程在执行，Python 的线程是操作系统的原生线程。在 Linux 上为 pthread，在 Windows 上为 Win thread，完全由操作系统调度线程的执行。一个 python 解释器进程内有一条主线程，以及多条用户程序的执行线程。即使在多核 CPU 平台上，由于 GIL 的存在，所以禁止多线程的并行执行。关于这个问题的折衷解决方法，我们在以后线程和进程章节里再进行详细探讨。
name ‘Alex Li’ age2 22 name + age2 Traceback (most recent call last): File ““, line 1, in TypeError: cannot concatenate ‘str’ and ‘int’ objects #错误提示数字 和 字符 不能拼接
6.3、布尔值（True，False）。
布尔类型很简单，就两个值 ，一个 True (真)，一个 False (假), 主要用记逻辑判断
但其实你们并不明白对么？ let me explain, 我现在有 2 个值 ， a=3, b=5 , 我说 a>b 你说成立么？我们当然知道不成立，但问题是计算机怎么去描述这成不成立呢？或者说 a< b 是成立，计算机怎么描述这是成立呢？
没错，答案就是，用布尔类型
a=3 b=5
a > b #不成立就是False,即假 False
a < b #成立就是True, 即真 True
7. 程序交互
#!/usr/bin/env python # -- coding: utf-8 --
将用户输入的内容赋值给 name 变量
name = input(“请输入用户名：”) # 打印输入的内容 print(name)
执行脚本就会发现，程序会等待你输入姓名后再往下继续走。
可以让用户输入多个信息，如下
1 2 3 4 5 6
#!/usr/bin/env python # -*- coding: utf-8 -*-
name = input("What is your name?") age = input("How old are you?") hometown = input("Where is your hometown?") print("Hello ",name , "your are ", age , "years old, you came from",hometown)
由于最近在 B 站直播的次数有点多，还有就是平时录制的视频也有点人看了，所以想多做点视频发布到 B 站上面，但是自己看了以前的视频，发现视频确实画面确实粗糙，不仅仅是视频不清晰的原因，更主要的是我眼睛看着黑苹果的2k 屏幕看久了眼睛莫名的难受，毕竟苹果的渲染方式和 Windows 的不太一样，所以觉得上4K 是一件最近要完成的事情，然后可以把我2k 的显示器给我搞设计的弟弟用。 于是乎赶上了 jd 的活动，一款 LG 的4K ips 屏幕仅售1799，评价上万了，大概看了一下评价，感觉还行于是就下单了，显示器第二天就到了，开机一开，显示器底座确实辣鸡的一，是我用过那么多显示器最辣鸡的一个了，满满的塑料感，感觉会被压塌一样。底座嘛，无所谓，我可以换一个挂壁，确实也用了一个挂壁的支架，但是先后发货可能是出厂地方不同吧，没有同时到货。于是搭建好显示器，开机搞了很久才能点亮，好像要设置输出，不然屏幕接收不到信号。然后在 Windows 环境下使用鲁大师屏幕检测，没有坏点，但是右下角有黑色的泛光，看起来难受得很，于是决定退货。
退完货，所有款都到手了之后就在去 JD 上面逛了一下，决定加点钱，在弄一个底座好一点的显示器，是就搞了一个只是旋转还有上下转动的显示器也同样是 LG这个牌子的，为什么，只因为 LG 屏这个是有口碑的，国产的 AOC 价格虽然更便宜一些，但是也不是很想入，银色款确实不是我的菜。于是2199搞了第二台4K 显示器，然后第二天又送货到了，然后这个底座比之前的要好上了一些，不满意的是显示器的电源线，是我没见过的一种线，生怕坏了难找到同一个规格的线，但是看在颜色上还算不错的份上，算了，装吧。于是又搭建好了显示器，然后又一次的失望了，显示器右边漏光严重，如果单纯只是漏光的话，在某一个范围之内我还是可以接受的，但是这样子的漏光我着实不敢恭维啊，看着我眼睛都快瞎了，然后立马申请换货了。
