C\#네트워크 프로 그래 밍 기초 프로 세 스 와 스 레 드 상세 설명

C\#의 네트워크 프로 그래 밍 에서 프로 세 스 와 스 레 드 는 필수 적 인 기초 지식 이자 중점 이기 때문에 우 리 는 잘 파악 해 야 한다.
개념
우선'프로 세 스'가 무엇 인지,'스 레 드'가 무엇 인지 알 아야 합 니 다.자,baike 를 찾 아 보 세 요.
프로 세 스:특정한 데이터 집합 에 대한 독립 적 인 기능 을 가 진 프로그램 입 니 다.이것 은 운영 체제 동적 실행 의 기본 단원 이다.
전통 적 인 운영 체제 에서 프로 세 스 는 기본 적 인 분배 단원 이자 기본 적 인 집행 단원 이다.
스 레 드:"프로 세 스"의 단일 순서 제어 흐름 입 니 다.
이 두 가지 개념 에 대해 서 는 조금 만 인상 을 남기 면 됩 니 다.나중에 면접 관 에 게 물 어보 지 않도록 하 세 요.
프로 세 스
framework 에서'프로 세 스'의 기본 작업 에 대한 패 키 징 은 좋 습 니 다.우리 의 실제 개발 중의 기본 적 인 응용 을 만족 시 킬 수 있 습 니 다.
<1>프로 세 스 정보 가 져 오기
framework 에서 프로 세 스 를 가 져 오 는 방법 은 매우 많 습 니 다.Name 에 따라 가 져 올 수도 있 고 ID 에 따라 가 져 올 수도 있 으 며 로 컬 과 원 격 프로 세 스 정 보 를 가 져 올 수도 있 습 니 다.

public Process[] GetProcess(string ip = "")

        {

            if (string.IsNullOrEmpty(ip))

                return Process.GetProcesses();
            return Process.GetProcesses(ip);

        }
Process process = Process.GetProcessById(Convert.ToInt32(processID));

<2>프로 세 스 시작 및 정지
사실 이것 도 할 말 이 없 지만 주의해 야 할 것 은 Process 의'kill'과'CloseMainWindow'의 차이 점 이다.
windowMainWindow:  우리 가 연 Process 가 인터페이스 가 있 는 프로그램 일 때 이 방법 을 사용 하 는 것 을 추천 합 니 다.이것 은 프로그램의 닫 기 단 추 를 누 르 는 것 과 같 습 니 다.kill 처럼 폭력 적 이지 않 고 질서정연 하 게 프로그램 을 종료 하 는 것 입 니 다.  
kill:이 단어 에 따 르 면 모두 가 무슨 뜻 을 알 고 있 을 것 입 니 다.그 역할 은 우리 가 연 Process 를 강제로 닫 는 것 입 니 다.흔히 우리 데이터 의 손실 을 초래 할 수 있 습 니 다.그래서 어 쩔 수 없 이 kill 을 사용 하지 마 세 요.물론 그래 픽 인터페이스 가 없 는 응용 프로그램 에서 kill 은 Process 를 끝 낼 수 있 는 유일한 전략 입 니 다.
<3>프로 세 스 작업 의 데모:

public class ProgessHelper
 {
  //     
  public static void MainProcess()
  {
   ProgessHelper helper = new ProgessHelper();

   var result = helper.GetProcess();

   helper.ShowProcess(result.Take(10).ToArray());

   Console.Write("
          ：");

   helper.ShowProcessSingle(Console.ReadLine());

   Console.Write("
          ：\t");

   var name = helper.StartProcess(Console.ReadLine());


   Console.WriteLine("      ，    ？(0,1)");

   if (Console.ReadLine() == "1")
   {
    helper.StopProcess(name);

    Console.WriteLine("    。");
   }
  }

  #region     
  /// <summary>
///     
/// </summary>
/// <param name="ip"></param>
/// <returns></returns>
  public Process[] GetProcess(string ip = "")
  {
   if (string.IsNullOrEmpty(ip))
    return Process.GetProcesses();

   return Process.GetProcesses(ip);
  }
  #endregion

  #region     
  /// <summary>
///     
/// </summary>
/// <param name="process"></param>
  public void ShowProcess(Process[] process)
  {
   Console.WriteLine("  ID\t    \t    \t\t    \t   ");

   foreach (var p in process)
   {
    try
    {
     Console.WriteLine("{0}\t{1}\t{2}M\t\t{3}\t{4}", p.Id, p.ProcessName.Trim(), p.WorkingSet64 / 1024.0f / 1024.0f,
                   p.StartTime, p.MainModule.FileName);
    }
    catch (Exception ex)
    {
     Console.WriteLine(ex.Message);
    }
   }
  }
  #endregion

  #region   ID       
  /// <summary>
///   ID       
/// </summary>
/// <param name="processID"></param>
  public void ShowProcessSingle(string processID)
  {
   Process process = Process.GetProcessById(Convert.ToInt32(processID));

   Console.WriteLine("

             ：
");

   try
   {
    var module = process.MainModule;

    Console.WriteLine("   :{0}
  {1}
  {2}
  :{3}", module.FileName, module.FileVersionInfo.FileVersion,
                   module.FileVersionInfo.FileDescription,
                   module.FileVersionInfo.Language);
   }
   catch (Exception e)
   {
    Console.WriteLine(e.Message);
   }
  }
  #endregion

  #region     
  /// <summary>
///     
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
  public string StartProcess(string fileName)
  {
   Process process = new Process();

   process.StartInfo = new ProcessStartInfo(fileName);

   process.Start();

   return process.ProcessName;
  }
  #endregion

  #region     
  /// <summary>
///     
/// </summary>
/// <param name="name"></param>
  public void StopProcess(string name)
  {
   var process = Process.GetProcessesByName(name).FirstOrDefault();

   try
   {
    process.CloseMainWindow();
   }
   catch (Exception ex)
   {
    Console.WriteLine(ex.Message);
   }
  }
  #endregion
 }

봐 봐,PPTV 진짜 열 렸 어.응,8 땡,Process 재 밌 어.
여 기 는 주의해 야 한다.
우 리 는 59 줄 에 Try Catch 를 추 가 했 습 니 다.이것 은 모든 Process 에 MainModule 속성 이 있 기 때 문 입 니 다.그러나 모든 MainModule 이 C\#에 의 해 가 져 올 수 있 는 것 은 아 닙 니 다.
다음 과 같은'접근 거부'가 나타 날 수 있 습 니 다.

스 레 드
같은 라인 의 관련 조작 도 프레임 워 크 안의 Thread 에 의 해 완벽 하 게 봉인 되 어 우리 의 작업량 을 크게 간소화 시 켰 다.자주 사용 하 는 조작 은 다음 과 같다.
<1>시작 스 레 드.
<2>스 레 드 종료.
<3>스 레 드 일시 정지.
<4>합병 라인.
이것 은 설명 해 야 합 니 다.예 를 들 어 t1 스 레 드 는 실행 과정 에서 t2 가 실 행 될 때 까지 기 다 려 야 계속 실 행 될 수 있 습 니 다.이때 우 리 는 t2 를 t1 에 합 쳐 야 합 니 다.즉,t1 코드 블록 에 t2.Join()을 쓰 면 됩 니 다.마찬가지 로 Join 에 도 t2 가 실행 되 든 안 되 든 t2 가 실행 되 기 를 기다 리 는 시간 을 추가 할 수 있 습 니 다.
<5>스 레 드 동기 화
아마 여러분 도 알다 시 피 다 중 스 레 드 는 시스템 의 스루풋 과 응답 시간 을 해결 하 는 동시에 우리 에 게 자물쇠,자원 경쟁 등 문 제 를 남 겼 습 니 다.그러면 우 리 는 어떻게 합 니까?
이 문제 들 을 해결 할 까요?하하,Anders Hejlsberg 라 는 선배 님 은 우리 에 게 동기 화 스 레 드 를 실현 하 는 종 류 를 많이 제공 해 주 셨 습 니 다.예 를 들 어 Mutex,Monitor 등 입 니 다.
Interlocked 와 AutoResetEvent,물론 실제 응용 에서 우 리 는 간략화 판 lock 을 사용 하 는 것 을 좋아 합 니 다.왜냐하면 이 게임 은 프로 그래 밍 을 간소화 하 는 동시에
프로그램 이 간단명료 해 보인다.
<6>  마찬가지 로 저도 예 를 들 겠 습 니 다.

public class ThreadHelper
 {
  public static void MainThread()
  {

   ThreadHelper helper = new ThreadHelper(100);

   Thread[] thread = new Thread[20];

   for (int i = 0; i < 20; i++)
   {
    thread[i] = new Thread(helper.DoTransactions);

    thread[i].Name = "  " + i;

   }

   foreach (var single in thread)
   {
    single.Start();
   }
  }

  int balance;

  object obj = new object();

  public ThreadHelper(int balance)
  {
   this.balance = balance;
  }

  #region     
  /// <summary>
///     
/// </summary>
/// <param name="amount"></param>
  public void WithDraw(int amount)
  {
   lock (obj)
   {
    if (balance <= 0)
    {
     Console.WriteLine("  ，     ");
     return;
    }

    if (balance >= amount)
    {
     Console.WriteLine("     :{0},  ：{1},    :{2}", balance, amount, balance - amount);
     balance = balance - amount;
    }
    else
    {
     Console.WriteLine("     :{0},  ：{1},    :{2}", balance, balance, balance = 0);
    }
   }
  }
  #endregion

  #region       
  /// <summary>
///       
/// </summary>
  public void DoTransactions(object obj)
  {
   int random = new Random().Next(4, 10);

   Thread.Sleep(5000);

   WithDraw(random);
  }
  #endregion
 }

우리 가 lock 을 추가 할 때 모든 것 이 정상 입 니 다.그러나 우리 가 lock 을 제거 할 때 스 레 드 들 이'자원 경쟁'을 하 는 현상 이 있 습 니까?아래 그림 에서 볼 수 있 듯 이 다음 과 같은 현상 이 나 타 났 다.
물론 이것 은 내 가 보고 싶 은 결과 가 아니 라 실제 응용 에서 얼마나 찾기 어 려 운 bug 일 까?

<8>스 레 드 탱크
위의 예 에서 저 는 20 개의 스 레 드 를 만들어 서 임 무 를 완 성 했 습 니 다.예 를 들 어 일부 실제 응용 에서 클 라 이언 트 의 모든 요청 서버 는 하나의 스 레 드 를 만들어 서 처리 해 야 합 니 다.
그러면 스 레 드 가 많 을 때 좋 은 일이 아니 라 시스템 자원 을 과도 하 게 사용 하여 메모리 가 소 모 될 수 있 습 니 다.그러면 자 연 스 럽 게'스 레 드 탱크'를 도입 할 것 입 니 다.
스 레 드 탱크:백 스테이지 에서 여러 가지 임 무 를 수행 하 는 집합 입 니 다.그 는 우리 가 스 레 드 에 대한 기본 적 인 조작 을 봉 했 습 니 다.우리 가 할 수 있 는 일 은'입구 방법'을 스 레 드 탱크 에 버 리 면 됩 니 다.
특징:  스 레 드 탱크 는 최대 스 레 드 수 제한 이 있 습 니 다.크기 가 서로 다른 기계 에서 차이 가 있 는 지,연못 의 스 레 드 가 모두 바 쁜 상태 일 때 나중에 들 어 가 는 방법 은 줄 을 서서 연못 에 빈 스 레 드 가 처리 할 때 까지 줄 을 서 있 습 니 다.
코드:수정 후 다음 과 같 습 니 다.

public static void MainThread()
  {

   ThreadHelper helper = new ThreadHelper(100);

   for (int i = 0; i < 20; i++)
   {
    ThreadPool.QueueUserWorkItem(new WaitCallback(helper.DoTransactions));
   }

   //Thread[] thread = new Thread[20];

//for (int i = 0; i < 20; i++)
//{
// thread[i] = new Thread(helper.DoTransactions);

// thread[i].Name = "  " + i;

//}

//foreach (var single in thread)
//{
// single.Start();
//}
  }