的暗许图标,管理修改

By admin in 4858.com on 2019年4月10日

先上1个不修改的样式,如下:

1.synchronized(object)

Git管理的是修改

第二步,对readme.txt做三个改动,比如加1行内容:

cat readme.txt
Git is a distributed version control system.
Git is free software distributed under the GPL.
Git has a mutable index called stage.
Git tracks changes. 

然后,添加:

$ git add readme.txt
$ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#       modified:   readme.txt
#

 

近来,假定你早就完全控制了暂存区的定义。下边,大家要探究的就是,为啥Git比任何版本控制系统规划得能够,因为Git跟踪并管制的是修改,而非文件。

你会问,什么是修改?比如您新增了一行,那便是3个修改,删除了一行,也是一个改动,更改了一些字符,也是二个修改,删了壹些又加了部分,也是3个改动,甚至创办3个新文件,也算三个改动。

为何说Git管理的是修改,而不是文本呢?我们依然坚实验。第1步,对readme.txt做1个改动,比如加一行内容:

$ cat readme.txt
Git is a distributed version control system.
Git is free software distributed under the GPL.
Git has a mutable index called stage.
Git tracks changes.

 

然后,添加:

$ git add readme.txt
$ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#       modified:   readme.txt
#

 

然后,再修改readme.txt

$ cat readme.txt 
Git is a distributed version control system.
Git is free software distributed under the GPL.
Git has a mutable index called stage.
Git tracks changes of files.

 

提交:

$ git commit -m "git tracks changes"
[master d4f25b6] git tracks changes
 1 file changed, 1 insertion(+)

 

付出后,再看看情形:

$ git status
# On branch master
# Changes not staged for commit:
#   (use "git add <file>..." to update what will be committed)
#   (use "git checkout -- <file>..." to discard changes in working directory)
#
#       modified:   readme.txt
#
no changes added to commit (use "git add" and/or "git commit -a")

 

哎,怎么第叁次的改动未有被交付?

别激动,我们想起一下操作进度:

率先次修改
-> git add -> 第四回修改 -> git commit

你看,我们日前讲了,Git管理的是修改,当您用git add一声令下后,在工作区的首先次修改被放入暂存区,准备交付,但是,在工作区的第3次修改并从未放入暂存区,所以,git commit只担负把暂存区的改动提交了,也正是率先次的修改被交付了,第二次的改动不会被交给。

提交后,用git diff HEAD -- readme.txt指令能够查阅工作区和版本Curry面最新版本的界别:

$ git diff HEAD -- readme.txt 
diff --git a/readme.txt b/readme.txt
index 76d770f..a9c5755 100644
--- a/readme.txt
+++ b/readme.txt
@@ -1,4 +1,4 @@
 Git is a distributed version control system.
 Git is free software distributed under the GPL.
 Git has a mutable index called stage.
-Git tracks changes.
+Git tracks changes of files.

 

看得出,第一回修改确实并未有被交给。

这怎么提交第三回修改呢?你能够继承git addgit commit,也得以别着急提交第三次修改,先git add其次次修改,再git commit,就一定于把五次修改合并后一块提交了:

第一遍修改
-> git add -> 第二回修改 -> git add的暗许图标,管理修改。 ->
git commit

好,今后,把第一回修改提交了,然后发轫小结。

import easygui as g

g.msgbox("hello","hi")
package test.thread;

import java.io.IOException;

import org.junit.Test;

/*
 * 测试线程锁
 */
public class TestBlock {

        public static void main(String[] args)  {
            TestBlock test = new TestBlock();
            MyTest thread1 = test.new MyTest(test);
            thread1.setName("1");
            MyTest thread2 = test.new MyTest(test);
            thread2.setName("2");
            thread1.start();
            thread2.start();
        }  
    /*
     * 测试同步
     */
    class MyTest extends Thread{
        private Object o;

        public  MyTest(Object o){
            this.o=o;
        }

        @Override
        public void run() {
            // TODO Auto-generated method stub
            synchronized (o) {  //这个o是test对象的实例 ,对类对象实例进行加锁,当线程调用一个实例运行的,另外的线程调用这个实例时候阻塞,达到上锁的目的
                try {
                    for(int a=0;a<3;a++){
                        System.out.println("线程"+MyTest.currentThread().getName()+"修改a=="+a);
                        //MyTest.yield();
                    }
                } catch (Exception e) {
                    // TODO: handle exception
                }

            }
        }

    }    

}

返回的结果:
  ·      

管制修改

阅读: 690131


近日,假定你已经完全精通了暂存区的概念。上面,大家要研讨的便是,为啥Git比任何版本控制系统规划得好好,因为Git跟踪并管制的是修改,而非文件。

您会问,什么是修改?比如您新增了一行,那正是贰个修改,删除了一行,也是一个改动,更改了某个字符,也是多少个修改,删了1些又加了部分,也是一个改动,甚至创办三个新文件,也算3个改动。

怎么说Git管理的是修改,而不是文本呢?我们照旧做试验。第一步,对readme.txt做贰个改动,比如加一行内容:

$ cat readme.txt
Git is a distributed version control system.
Git is free software distributed under the GPL.
Git has a mutable index called stage.
Git tracks changes.

然后,添加:

$ git add readme.txt
$ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#       modified:   readme.txt
#

然后,再修改readme.txt:

$ cat readme.txt 
Git is a distributed version control system.
Git is free software distributed under the GPL.
Git has a mutable index called stage.
Git tracks changes of files.

提交:

$ git commit -m "git tracks changes"
[master d4f25b6] git tracks changes
 1 file changed, 1 insertion(+)

付出后,再看看情形:

$ git status
# On branch master
# Changes not staged for commit:
#   (use "git add <file>..." to update what will be committed)
#   (use "git checkout -- <file>..." to discard changes in working directory)
#
#       modified:   readme.txt
#
no changes added to commit (use "git add" and/or "git commit -a")

率先次修改 -> git add -> 第二遍修改 -> git commit

,Git管理的是修改,当你用git add指令后,在工作区的率先次修改被放入暂存区,准备付出,不过,在工作区的第一遍修改并未放入暂存区,所以,git commit只担负把暂存区的改动提交了,也等于率先次的修改被交给了,第壹回的修改不会被提交。

提交后,用git diff HEAD -- readme.txt一声令下能够查看工作区和版本Curry面最新版本的区分:

$ git diff HEAD -- readme.txt 
diff --git a/readme.txt b/readme.txt
index 76d770f..a9c5755 100644
--- a/readme.txt
+++ b/readme.txt
@@ -1,4 +1,4 @@
 Git is a distributed version control system.
 Git is free software distributed under the GPL.
 Git has a mutable index called stage.
-Git tracks changes.
+Git tracks changes of files.

小结

今日,你又掌握了Git是如何跟踪修改的,每一回修改,倘诺不add到暂存区,那就不会进入到commit中。

 

     

管理修改

阅读: 690131


前几天,假定你早就完全控制了暂存区的定义。下边,大家要探究的正是,为何Git比任何版本控制系统规划得好好,因为Git跟踪并管制的是修改,而非文件。

你会问,什么是修改?比如您新增了一行,那正是二个修改,删除了1行,也是一个改动,更改了几许字符,也是1个改动,删了一些又加了部分,也是叁个改动,甚至创建一个新文件,也算一个修改。

为何说Git管理的是修改,而不是文本呢?大家还是做尝试。第三步,对readme.txt做三个改动,比如加1行内容:

$ cat readme.txt
Git is a distributed version control system.
Git is free software distributed under the GPL.
Git has a mutable index called stage.
Git tracks changes.

然后,添加:

$ git add readme.txt
$ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#       modified:   readme.txt
#

然后,再修改readme.txt:

$ cat readme.txt 
Git is a distributed version control system.
Git is free software distributed under the GPL.
Git has a mutable index called stage.
Git tracks changes of files.

提交:

$ git commit -m "git tracks changes"
[master d4f25b6] git tracks changes
 1 file changed, 1 insertion(+)

提交后,再看看动静:

$ git status
# On branch master
# Changes not staged for commit:
#   (use "git add <file>..." to update what will be committed)
#   (use "git checkout -- <file>..." to discard changes in working directory)
#
#       modified:   readme.txt
#
no changes added to commit (use "git add" and/or "git commit -a")

哎呀,怎么第一遍的改动未有被交付?

别激动,大家回看一下操作进程:

首先次修改 -> git add -> 第三回修改 -> git commit

你看,大家近期讲了,Git管理的是修改,当你用git add4858.com ,指令后,在工作区的第一次修改被放入暂存区,准备提交,不过,在工作区的第1回修改并不曾放入暂存区,所以,git commit只承担把暂存区的修改提交了,也正是第一回的改动被提交了,首回的修改不会被交付。

提交后,用git diff HEAD -- readme.txt命令能够查看工作区和版本Curry面最新版本的区分:

$ git diff HEAD -- readme.txt 
diff --git a/readme.txt b/readme.txt
index 76d770f..a9c5755 100644
--- a/readme.txt
+++ b/readme.txt
@@ -1,4 +1,4 @@
 Git is a distributed version control system.
 Git is free software distributed under the GPL.
 Git has a mutable index called stage.
-Git tracks changes.
+Git tracks changes of files.

足见,第四回修改确实尚未被交给。

那怎么提交第1回修改呢?你能够延续git addgit commit,也得以别着急提交第1回修改,先git add其次次修改,再git commit,就一定于把一回修改合并后1块提交了:

率先次修改 -> git add -> 第3回修改 -> git add ->
git commit


留意左上角的图标为革命的Tk字样

线程1修改a==0
线程1修改a==1
线程1修改a==2
线程1修改a==3
线程1修改a==4
线程1修改a==5
线程1修改a==6
线程1修改a==7
线程1修改a==8
线程1修改a==9
线程2修改a==0
线程2修改a==1
线程2修改a==2
线程2修改a==3
线程2修改a==4
线程2修改a==5
线程2修改a==6
线程2修改a==7
线程2修改a==8
线程2修改a==9

小结

  • git add (文件名/*)把代码添加到工作区中(暂存区)
  • git commit -am "message"交付到版本库

干什么 Git 比其余版本控制系统规划得优良,因为 Git
跟踪并管理的是修改,而非文件。 git commit 只负责把暂存区的修改提交了。
每一回修改,如若不 add 到暂存区,那就不会参与到 commit 中。
主要注意上面多少个指令

git diff    #是工作区(work dict)和暂存区(stage)的比较
git diff --cached    #是暂存区(stage)和分支(master)的比较
git diff HEAD  #查看工作区和版本库里面最新版本的区别

 4858.com 1

可以看到当一个线程运行完毕之后才运行第二个线程

 

2.synchronized(this)

修改后:

package test.thread;

import java.io.IOException;

import org.junit.Test;

/*
 * 测试线程锁
 */
public class TestBlock {   //调用类

        public static void main(String[] args)  {
            TestBlock test = new TestBlock();
            MyTest thread1 = test.new MyTest(test);
            thread1.setName("1");
            MyTest thread2 = test.new MyTest(test);
            thread2.setName("2");
            thread1.start();
            thread2.start();
        }  
    /*
     * 测试同步
     */
    class MyTest extends Thread{
        private Object o;

        public  MyTest(Object o){
            this.o=o;
        }

        @Override
        public void run() {
            // TODO Auto-generated method stub
            synchronized (this) {  //this 指代当时类 也就是MyTest,两个线程同时调用同一个类方法。就是两个线程对两个实例的各自上锁。互相不阻塞

try { for(int a=0;a<10;a++){ System.out.println("线程"+MyTest.currentThread().getName()+"修改a=="+a); //MyTest.yield();  } } catch (Exception e) { // TODO: handle exception  } } } } }

返回的结果:
import easygui as g
from Tkinter import *
tk = Tk()

tk.iconbitmap(default = r'C:\Users\xxoo\Downloads\bitbug_favicon.ico')

g.msgbox("hello","hi")

线程1修改a==0
线程1修改a==1
线程1修改a==2
线程1修改a==3
线程1修改a==4
线程2修改a==0
线程1修改a==5
线程1修改a==6
线程1修改a==7
线程1修改a==8
线程1修改a==9
线程2修改a==1
线程2修改a==2
线程2修改a==3
线程2修改a==4
线程2修改a==5
线程2修改a==6
线程2修改a==7
线程2修改a==8
线程2修改a==9

  

 

展示如下:

 

4858.com 2

 

 

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有