2. 程式人生 > >WPF BackgroundWorker執行緒與進度的處理

WPF BackgroundWorker執行緒與進度的處理

阿新 • • 發佈：2018-12-17

簡介：

        開發過程中經常遇到一些費時的操作介面，比如統計某個磁碟分割槽的資料夾或者檔案數目，如果分割槽很大或者檔案過多的話，處理不好就會造成“假死”的情況，或者報“執行緒間操作無效”的異常，為了解決這個問題，可以使用委託來處理，在.net2.0中還可以用BackgroundWorker類。BackgroundWorker類是.net 2.0裡新增加的一個類，對於需要長時間操作而不需要使用者長時間等待的情況可以使用這個類。

注意：

        確保在 DoWork 事件處理程式中不操作任何使用者介面物件。而應該通過 ProgressChanged 和 RunWorkerCompleted 事件與使用者介面進行通訊。

案例：

        引用：System.dll       下載：http://download.csdn.net/detail/qq_33538554/9690615

原始碼：

----------------------MainWindow.xaml

<Windowxmlns:dxc="http://schemas.devexpress.com/winfx/2008/xaml/charts"  
        x:Class

="MobilePlugfest.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:local="clr-namespace:MobilePlugfest"
        Height
="300" Width="400"
        Background="Transparent"
        WindowStyle="None"
        AllowsTransparency="True">
    <Window.Resources>
        <ResourceDictionary>
            <!--引用進度條-->
            <local:ValueToProcessConverter x:Key="ValueToProcessConverter"/>
            <!--設定字型顏色-->
            <Style  x:Key="lab" TargetType="Label">
                <Setter Property="Foreground"Value="Red"></Setter>
            </Style>
            <!--系統提示字型顏色-->
            <Style  x:Key="TextBox" TargetType="TextBox">
                <Setter Property="Foreground"Value="Red"></Setter>
            </Style>
        </ResourceDictionary>
    </Window.Resources>
    <Grid>
        <!--設定窗體透明化-->
        <Border CornerRadius="5"BorderThickness="2" BorderBrush="White"Opacity="0.8">
            <Border.Effect>
                <DropShadowEffect ShadowDepth="0"Color="#FF414141"BlurRadius="8"/>
            </Border.Effect>
            <Border Background="Black"Opacity="0.5" CornerRadius="5">
                <!--系統提示框-->
                <TextBox  Name="txtLog"Background="Black"Height="250"Width="200"Margin="0,0,140,0"Style="{StaticResourceResourceKey=TextBox}"/>
            </Border>
        </Border>
        <!--進度條-->
        <ProgressBar Minimum="0"Maximum="100"Name="progressBar"Height="60"Width="60"Margin="200,0,0,180">
            <ProgressBar.Template>
                <ControlTemplate TargetType="ProgressBar">
                    <Border Background="{TemplateBindingValue,Converter={StaticResourceValueToProcessConverter},ConverterParameter=200}"
                            MouseLeftButtonDown="Border_MouseLeftButtonDown_1"/>
                </ControlTemplate>
            </ProgressBar.Template>
        </ProgressBar>
        <!--顯示進度-->
        <Label Name="labTip" Style="{StaticResourcelab}"Height="100"Width="100"Margin="240,0,0,0"/>
    </Grid>
</Window>

----------------------MainWindow.xaml.cs

using SocketStd;//SocketStd
using System;
using System.Collections.Generic;
using System.ComponentModel;//BackgroundWorker
using System.Linq;
using System.Net;
using System.Net.Sockets;//TcpClient
using System.Text;
using System.Threading;//Thread
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
using System.Configuration;//ConfigurationManager

namespace MobilePlugfest
{
    /// <summary>
    /// MainWindow.xaml 的互動邏輯
    /// </summary>
    public partial class MainWindow : Window
    {
        BackgroundWorker bgWorker;
        double scannedCount = Convert.ToDouble(ConfigurationManager.AppSettings["ScannedCount"]);
        int runningThreadCount = Convert.ToInt32(ConfigurationManager.AppSettings["RunningThreadCount"]);
        static int maxThread = Convert.ToInt32(ConfigurationManager.AppSettings["MaxThread"]);
        string host = ConfigurationManager.AppSettings["Host"].ToString();
        int port = Convert.ToInt32(ConfigurationManager.AppSettings["Port"]);
        int startIP = Convert.ToInt32(ConfigurationManager.AppSettings["StartIP"]);
        int endIP = Convert.ToInt32(ConfigurationManager.AppSettings["EndIP"]);
        string addresIP = ConfigurationManager.AppSettings["AddresIP"].ToString();

        public MainWindow()
        {
            bgWorker = new BackgroundWorker();
            //進度更新報告true
            bgWorker.WorkerReportsProgress = true;
            //非同步取消true
            bgWorker.WorkerSupportsCancellation = true;
            //後臺操作任務
            bgWorker.DoWork += DoWork_Handler;
            //後臺操作進行時
            bgWorker.ProgressChanged += ProgressChanged_Handler;
            //後臺操作完成
            bgWorker.RunWorkerCompleted += RunWorkerCompleted_Handler;
        }
        /// <summary>
        /// 進度條的點選事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Border_MouseLeftButtonDown_1(object sender, MouseButtonEventArgs e)
        {
            if (!bgWorker.IsBusy)
            {
                if (txtLog.Text != "") txtLog.Text = "";
                scannedCount = 0;
                //開始執行後臺操作任務
                bgWorker.RunWorkerAsync();
            }
        }
        /// <summary>
        /// 後臺操作任務
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void DoWork_Handler(object sender, DoWorkEventArgs e)
        {
            double total = Convert.ToDouble(endIP - startIP + 1);
            for (int ip = startIP; ip <= endIP; ip++)
            {
                if (bgWorker.CancellationPending)
                {
                    e.Cancel = true;
                    break;
                }
                //IP地址段，預設：192.168.1.
                host = addresIP + ip.ToString();
                //帶引數的多執行緒執行
                Thread thread = new Thread(() => Scan(host, port));
                thread.IsBackground = true;
                thread.Start();
                UpdateLabText(labTip, string.Format("正在掃描...\r\n第{0}臺\r\n共{1}臺\r\n進度：{2}%", scannedCount, total, Convert.ToInt32((scannedCount / total) * 100)));
                bgWorker.ReportProgress(Convert.ToInt32((scannedCount / total) * 100));
                runningThreadCount++;
                Thread.Sleep(10);//節省cpu資源
                //迴圈，直到某個執行緒工作完畢才啟動另一新執行緒，也可以叫做推拉窗技術
                while (runningThreadCount >= maxThread) ;
            }
            //空迴圈，直到所有埠掃描完畢
            do
            {
                UpdateLabText(labTip, string.Format("正在掃描...\r\n第{0}臺\r\n共{1}臺\r\n進度：{2}%", scannedCount, total, Convert.ToInt32((scannedCount / total) * 100)));
                bgWorker.ReportProgress(Convert.ToInt32((scannedCount / total) * 100));
                Thread.Sleep(10);
            } while (runningThreadCount > 0);
        }
        /// <summary>
        /// 後臺操作進行時
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ProgressChanged_Handler(object sender, ProgressChangedEventArgs e)
        {
            progressBar.Value = e.ProgressPercentage;
        }
        /// <summary>
        /// 後臺操作完成
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void RunWorkerCompleted_Handler(object sender, RunWorkerCompletedEventArgs e)
        {
            labTip.Content = "掃描完成！";
        }
        /// <summary>
        /// 判斷ip埠是否為開放狀態
        /// </summary>
        /// <param name="m_host"></param>
        /// <param name="m_port"></param>
        public void Scan(string m_host, int m_port)
        {
            //高階的TcpClient類
            TcpClient tc = new TcpClient();
            //設定超時時間
            tc.SendTimeout = tc.ReceiveTimeout = 2000;
            try
            {
                //同步方法
                //IPAddress ip = IPAddress.Parse(host);
                //IPEndPoint IPendp = new IPEndPoint(ip, port);
                //tc.Connect(IPendp);

                //非同步方法
                IAsyncResult oAsyncResult = tc.BeginConnect(m_host, m_port, null, null);
                //1000為超時時間
                oAsyncResult.AsyncWaitHandle.WaitOne(1000, true);
                if (tc.Connected)
                {
                    //如果連線上，證明此埠為開放狀態
                    UpdateListBox(txtLog, m_host + ":" + m_port.ToString());
                }
            }
            catch (System.Net.Sockets.SocketException e)
            {
                //容錯處理
                MessageBox.Show("Port {0} is closed", host.ToString());
                Console.WriteLine(e.Message);
            }
            finally
            {
                tc.Close();
                tc = null;
                scannedCount++;
                runningThreadCount--;
            }
        }

        delegate void SetLabCallback(System.Windows.Controls.Label lb, string text);
        /// <summary>
        /// 非同步控制元件Label
        /// </summary>
        /// <param name="lb"></param>
        /// <param name="text"></param>
        public void UpdateLabText(System.Windows.Controls.Label lb, string text)
        {
            //InvokeRequired
            if (System.Threading.Thread.CurrentThread != lb.Dispatcher.Thread)
            {
                //控制元件只能由建立它的執行緒來訪問。其他執行緒想訪問必須呼叫該控制元件的Invoke方法。Invoke有兩個引數，一個是委託方法，一個是引數值
                SetLabCallback d = new SetLabCallback(UpdateLabText);
                this.Dispatcher.Invoke(d, new object[] { lb, text });
            }
            else
            {
                lb.Content = text.Trim();
            }
        }

        delegate void SetListCallback(System.Windows.Controls.TextBox lstBox, string text);
        /// <summary>
        /// 非同步控制元件TextBox
        /// </summary>
        /// <param name="lstBox"></param>
        /// <param name="text"></param>
        private void UpdateListBox(System.Windows.Controls.TextBox lstBox, string text)
        {
            if (System.Threading.Thread.CurrentThread != lstBox.Dispatcher.Thread)
            {
                SetListCallback d = new SetListCallback(UpdateListBox);
                this.Dispatcher.Invoke(d, new object[] { lstBox, text });
            }
            else
            {
                ShowMsg("系統提示：", "" + text.Trim() + "");
                txtLog.Text = SingleObject.GetSingle().LogString.ToString();
                txtLog.SelectionStart = txtLog.Text.Length;
                txtLog.SelectionLength = 0;
                txtLog.ScrollToEnd();
            }
        }
        /// <summary>
        /// 系統提示模板
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="msg"></param>
        private void ShowMsg(string sender, string msg)
        {
            string time = DateTime.Now.ToString("hh:mm:ss");
            SingleObject.GetSingle().LogString.AppendLine(time + "    " + sender);
            SingleObject.GetSingle().LogString.AppendLine(msg);
            SingleObject.GetSingle().LogString.AppendLine();
        }
    }
}

---------------------App.config

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <startup>
        <supportedRuntime version="v4.0"sku=".NETFramework,Version=v4.5" />
    </startup>
  <appSettings>
    <!--已掃描埠數目-->
    <add key ="ScannedCount" value="0"/>
    <!--正在執行的執行緒數目-->
    <add key ="RunningThreadCount" value ="0"/>
    <!--最大工作執行緒數-->
    <add key ="MaxThread" value ="100"/>
    <!--IP地址-->
    <add key ="Host" value ="null"/>
    <!--埠-->
    <add key ="Port" value ="80"/>
    <!--Ip數量-->
    <add key ="EndIP" value ="255"/>
    <!--Ip 192.168.1.1-->
    <add key ="StartIP" value ="1"/>
    <!--IP地址段-->
    <add key ="AddresIP" value ="192.168.1."/>
  </appSettings>
</configuration>

----------------------SingleObject.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;

namespace SocketStd
{
    public class SingleObject
    {
        private static SingleObject _singleObject;
        private SingleObject()
        {
            this.LogString = new StringBuilder();
            this.ConnectedSocket = new Dictionary<string,Socket>();
            this.IsMove = false;
            this.LastSendedFile = "";
        }
        public static SingleObject GetSingle()
        {
            if (_singleObject == null)
            {
                _singleObject = new SingleObject();
            }
            return _singleObject;
        }
        private StringBuilder_logString;
        public StringBuilderLogString
        {
            get
            {
                return _logString;
            }
            set
            {
                _logString = value;
            }
        }
        private Dictionary<string,Socket> _connectedSocket;
        public Dictionary<string,Socket> ConnectedSocket
        {
            get
            {
                return _connectedSocket;
            }
            set
            {
                _connectedSocket = value;
            }
        }
        private bool _isMove;
        public bool IsMove
        {
            get
            {
                return _isMove;
            }
            set
            {
                _isMove = value;
            }
        }
        private string _lastSendedFile;
        public string LastSendedFile
        {
            get
            {
                return _lastSendedFile;
            }
            set
            {
                _lastSendedFile = value;
            }
        }
    }
}
---------------------ValueToProcessConverter.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Globalization;
using System.Windows;
using System.Windows.Data;
using System.Windows.Media;

namespace MobilePlugfest
{
    public class ValueToProcessConverter:IValueConverter
    {
        private const double Thickness = 8;
        private const double Padding = 1;
        private const double WarnValue = 60;
        private const int SuccessRateFontSize = 34;
        private static readonly SolidColorBrush NormalBrush;
        private static readonly SolidColorBrush WarnBrush;
        private static readonly Typeface SuccessRateTypeface;

        private string percentString;
        private PointcenterPoint;
        private double radius;

        static ValueToProcessConverter()
        {
            NormalBrush=new SolidColorBrush(Colors.Green);
            WarnBrush=new SolidColorBrush(Colors.Red);
            SuccessRateTypeface=new Typeface(newFontFamily("MSYH"),newFontStyle(),newFontWeight(),newFontStretch());
        }

        public ValueToProcessConverter()
        {

        }

        public object Convert(objectvalue,Type targetType, objectparameter, System.Globalization.CultureInfoculture)
        {
            if (value is double && !string.IsNullOrEmpty((string)parameter))
            {
                double arg = (double)value;
                double width = double.Parse((string)parameter);
                radius = width / 2;
                centerPoint = new Point(radius, radius);
                return DrawBrush(arg, 100, radius, radius, Thickness, Padding);
            }
            else
            {
                throw new ArgumentException();
            }
        }

        public object ConvertBack(objectvalue,Type targetType, objectparameter, System.Globalization.CultureInfoculture)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// 根據角度獲取座標
        /// </summary>
        /// <param name="CenterPoint"></param>
        /// <param name="r"></param>
        /// <param name="angel"></param>
        /// <returns></returns>
        private PointGetPointByAngel(PointCenterPoint, double r, double angel)
        {
            Point p = new Point();
            p.X = Math.Sin(angel * Math.PI / 180) * r + CenterPoint.X;
            p.Y = CenterPoint.Y - Math.Cos(angel *Math.PI / 180) * r;
            return p;
        }

        /// <summary>
        /// 根據4個座標畫出扇形
        /// </summary>
        /// <param name="bigFirstPoint"></param>
        /// <param name="bigSecondPoint"></param>
        /// <param name="smallFirstPoint"></param>
        /// <param name="smallSecondPoint"></param>
        /// <param name="bigRadius"></param>
        /// <param name="smallRadius"></param>
        /// <param name="isLargeArc"></param>
        /// <returns></returns>
        private GeometryDrawingArcGeometry(PointbigFirstPoint,Point bigSecondPoint, Point smallFirstPoint, Point smallSecondPoint,doublebigRadius, double smallRadius, bool isLargeArc)
        {
            PathFigure pathFigure = new PathFigure { IsClosed = true };
            pathFigure.StartPoint = bigFirstPoint;
            pathFigure.Segments.Add(
              new ArcSegment
              {
                  Point = bigSecondPoint,
                  IsLargeArc = isLargeArc,
                  Size = new Size(bigRadius, bigRadius),
                  SweepDirection = SweepDirection.Clockwise
              });
            pathFigure.Segments.Add(new LineSegment { Point = smallSecondPoint });
            pathFigure.Segments.Add(
             new ArcSegment
             {
                 Point = smallFirstPoint,
                 IsLargeArc = isLargeArc,
                 Size = new Size(smallRadius, smallRadius),
                 SweepDirection = SweepDirection.Counterclockwise
             });
            PathGeometry pathGeometry = new PathGeometry();
            pathGeometry.Figures.Add(pathFigure);
            return pathGeometry;
        }

        /// <summary>
        /// 根據當前值和最大值獲取扇形
        /// </summary>
        /// <param name="value"></param>
        /// <param name="maxValue"></param>
        /// <returns></returns>
        private GeometryGetGeometry(doublevalue, double maxValue, double radiusX, double radiusY, double thickness, double padding)
        {
            bool isLargeArc = false;
            double percent = value / maxValue;
            percentString = string.Format("{0}%",Math.Round(percent * 100));
            double angel = percent * 360D;
            if (angel > 180) isLargeArc = true;
            double bigR = radiusX;
            double smallR = radiusX - thickness + padding;
            Point firstpoint = GetPointByAngel(centerPoint, bigR, 0);
            Point secondpoint = GetPointByAngel(centerPoint, bigR, angel);
            Point thirdpoint = GetPointByAngel(centerPoint, smallR, 0);
            Point fourpoint = GetPointByAngel(centerPoint, smallR, angel);
            return DrawingArcGeometry(firstpoint, secondpoint, thirdpoint, fourpoint, bigR, smallR, isLargeArc);
        }

        private void DrawingGeometry(DrawingContextdrawingContext,double value, doublemaxValue, double radiusX, double radiusY, double thickness, double padding)
        {
            if (value != maxValue)
            {
                SolidColorBrush brush;
                if (value < WarnValue)
                {
                    brush = WarnBrush;
                }
                else
                {
                    brush = NormalBrush;
                }
                drawingContext.DrawEllipse(null,newPen(newSolidColorBrush(Color.FromRgb(0xdd, 0xdf, 0xe1)), thickness), centerPoint, radiusX, radiusY);
                drawingContext.DrawGeometry(brush, newPen(), GetGeometry(value, maxValue, radiusX, radiusY, thickness, padding));
                FormattedText formatWords = new FormattedText(percentString,
                    CultureInfo.CurrentCulture,
                    FlowDirection.LeftToRight,
                    SuccessRateTypeface,
                    SuccessRateFontSize,
                    brush);
                Point startPoint = new Point(centerPoint.X - formatWords.Width / 2, centerPoint.Y - formatWords.Height / 2);
                drawingContext.DrawText(formatWords, startPoint);
            }
            else
            {
                drawingContext.DrawEllipse(null,newPen(NormalBrush, thickness), centerPoint, radiusX, radiusY);
                FormattedText formatWords = new FormattedText("100%",
                    CultureInfo.CurrentCulture,
                    FlowDirection.LeftToRight,
                    SuccessRateTypeface,
                    SuccessRateFontSize,
                    NormalBrush);
                Point startPoint = new Point(centerPoint.X - formatWords.Width / 2, centerPoint.Y - formatWords.Height / 2);
                drawingContext.DrawText(formatWords, startPoint);
            }
            drawingContext.Close();
        }

        /// <summary>
        /// 根據當前值和最大值畫出進度條
        /// </summary>
        /// <param name="value"></param>
        /// <param name="maxValue"></param>
        /// <returns></returns>
        private VisualDrawShape(doublevalue, double maxValue, double radiusX, double radiusY, double thickness, double padding)
        {
            DrawingVisual drawingWordsVisual =newDrawingVisual();
            DrawingContext drawingContext = drawingWordsVisual.RenderOpen();
            DrawingGeometry(drawingContext, value, maxValue, radiusX, radiusY, thickness, padding);
            return drawingWordsVisual;
        }

        /// <summary>
        ///根據當前值和最大值畫出進度條
        /// </summary>
        /// <param name="value"></param>
        /// <param name="maxValue"></param>
        /// <returns></returns>
        private BrushDrawBrush(doublevalue, double maxValue, double radiusX, double radiusY, double thickness, double padding)
        {
            DrawingGroup drawingGroup = new DrawingGroup();
            DrawingContext drawingContext = drawingGroup.Open();
            DrawingGeometry(drawingContext, value, maxValue, radiusX, radiusY, thickness, padding);
            DrawingBrush brush = new DrawingBrush(drawingGroup);
            return brush;
        }
    }
}

截圖：




相關推薦

WPF BackgroundWorker執行緒與進度的處理

簡介：         開發過程中經常遇到一些費時的操作介面，比如統計某個磁碟分割槽的資料夾或者檔案數目，如果分割槽很大或者檔案過多的話，處理不好就會造成“假死”的情況，或者報“執行緒間操作無效”的異常，為了解決這個問題，

關於執行緒與訊號處理函式獲得同一把互斥鎖的問題 (原)

轉發請註明出處：http://www.cppblog.com/mysileng/admin/EditPosts.aspx?postid=196971    剛寫了程式發現點問題。假設一個程式有多個執行緒，有一個全域性互斥鎖M....在某執行緒A獲得鎖以後，這個時候來了一個訊號(假設這個訊號註冊了自己的處理程式

python多執行緒與進度條的結合

我把其中最關鍵的部分通過一個簡單的例子來說明： import threading import tkinter as tk from time import ctime,sleep # 建立主視窗 window = tk.Tk() window.title('測試')

一步步動手實現高併發的Reactor模型 —— Kafka底層如何充分利用多執行緒優勢去處理網路I/O與業務分發

一、從《Apeche Kafka原始碼剖析》上搬來的概念和圖 Kafka網路採用的是Reactor模式，是一種基於事件驅動的模式。熟悉Java程式設計的讀者應該瞭解Java NIO提供了Reactor模式的API。常見的單執行緒Java NIO程式設計模式如圖所示。 熟悉NIO程式設計都應該知道這個Sele

C#.網路程式設計 Socket基礎（四） WPF系統Socket TCP協議 伺服器與客戶端 不同型別檔案傳輸，同時解決UI執行緒與工作執行緒的卡頓問題

一、簡介 雖然，本文的前面幾篇文章在WinForm中實現了Socket TCP協議 伺服器與客戶端 不同型別檔案傳輸，詳情見 但是，卻沒有在WPF中實現 Socket TCP協議 伺服器與客戶端 不同型別檔案傳輸。因此，本文將描述如何在WPF中實現該功能。

1、執行緒與程序

一、程序： 定義：  程序是具有一定功能的程式在一個數據集合上的執行過程，它是系統進行資源分配和排程管理的一個可併發執行的基本單位。 理解：        1、每個程序擁有獨立的程式碼和資料空間。    

WPF多執行緒更改UI控制元件問題

無論是在WINFORM中，還是在WPF中，在涉及到複雜的邏輯關係時，如果在非同步執行緒中需要更改介面控制元件，需要通過以下機制進行操作，從而達到非同步更改介面控制元件的目的。 即   Dispatcher.Invoke(new Action(() =>   &nbs

使用者級執行緒與核心級執行緒

1、使用者級執行緒 把整個執行緒實現部分放在使用者空間中，核心對執行緒一無所知，核心看到的就是一個單執行緒程序。 只有一個使用者棧 優點： 1）整個使用者級執行緒的切換髮生在使用者空間，這樣的執行緒切換至少比陷入核心要快一個數量級

Java併發程式設計（4）：守護執行緒與執行緒阻塞的四種情況

守護執行緒Java中有兩類執行緒：User Thread(使用者執行緒)、Daemon Thread(守護執行緒) 使用者執行緒即執行在前臺的執行緒，而守護執行緒是執行在後臺的執行緒。 守護執行緒作用是為其他前臺執行緒的執行提供便利服務，而且僅在普通、非守護執行緒仍然執行時才需要，比如垃圾回收執行緒就是一個

多執行緒與高併發基礎知識

一、概覽 多執行緒主要知識點： 執行緒安全、執行緒封閉、執行緒排程、同步容器、併發容器、AQS、J.U.C 高併發解決方案： 擴容、快取、佇列、拆分、服務降級與熔斷、資料庫切庫、分庫分表 二、併發 概念： 同時擁有兩個或者多個執行緒，如果程式在單核處理器上執行

程序、執行緒與協程

程序 程序的出現是為了更好的利用CPU資源使到併發成為可能。 假設有兩個任務A和B，當A遇到IO操作，CPU默默的等待任務A讀取完操作再去執行任務B，這樣無疑是對CPU資源的極大的浪費。聰明的老大們就在想若在任務A讀取資料時，讓任務B執行，當任務A讀取完資料後，再切換到任務A執行。注意關

執行緒與訊號 -- pthread_sigmask() sigwait()

一、主執行緒傳送USR1訊號給子執行緒1  ，子執行緒中新增 訊號捕捉，子執行緒2沒有捕捉訊號，導致直接退出 #include <stdio.h> #include <pthread.h> #include <stdlib.h> #include &

程序、執行緒與多執行緒

一、說說概念 1、程序（process） 狹義定義：程序就是一段程式的執行過程。 廣義定義：程序是一個具有一定獨立功能的程式關於某個資料集合的一次執行活動。它是作業系統動態執行的基本單元，在傳統的作業系統中，程序既是基本的分配單元，也是基本的執行單元。 簡單的來講程序的概念主

hibernate本地執行緒與session繫結

         hibernate本地執行緒與session繫結：一個專案完成後可能有多個人同時操作，無法保證session是一個唯一的物件。若要保證session是唯一的物件，就要將session與本地執行緒繫結。 在overstackove

多執行緒基礎7 多執行緒與併發庫

多執行緒與併發庫 BlockingQueue佇列 BlockingQueue,如果BlockQueue是空的,從BlockingQueue取東西的操作將會被阻斷進入等待狀態,直到BlockingQueue進了東西才會被喚醒.同樣,如果BlockingQueue是滿的,任何試圖往裡存東西的操作

Android中的執行緒與執行緒池

執行緒與執行緒池 概括 執行緒分為主執行緒和子執行緒. 主執行緒主要是用來處理和介面相關的事情, 子執行緒主要是用來做耗時的操作,比如 載入遠端資料,資料庫操作等。 在android 中,處理直接使用 Thread以外。 android 還提供了很多類似執行緒的操作便於我們

2017.10.12 C#多執行緒與非同步的區別

最近在寫個多執行緒處理的程式，又重新溫習了一下相關知識，記錄在這裡。 C#多執行緒與非同步的區別 原文地址：http://kb.cnblogs.com/page/116095/ 多執行緒和非同步操作的異同 　　多執行緒和非同步操作兩者都可以達到避免呼叫執行緒阻塞的目的，從而提高軟體

Qt 筆記：多執行緒與介面元件的通訊（上）

是否可以在子執行緒中建立介面元件？ class TestThread : public QThread { Q_OBJECT protected: void run() { QWidget w; w.show();

Qt：筆記：多執行緒與介面元件的通訊（下）

子執行緒能夠更改介面元件狀態的本質是什麼？ -子執行緒發射訊號通知主執行緒介面更新請求；主執行緒根據具體訊號遺蹟訊號引數對介面元件進行修改。 是否有其他間接的方式可以讓子執行緒更新介面元件的狀態？ 解決方案 - 傳送自定義事件 -自定義事件類用於描述介面更新細節 -在主視窗類中重

C# 前臺執行緒與後臺執行緒

由於時間片的原因，雖然所有執行緒在微觀上是序列執行的，但在巨集觀上可以認為是並行執行。 執行緒有兩種型別：前臺和後臺。我們可以通過執行緒屬性IsBackground=false來指定執行緒的前後臺屬性（預設是前臺執行緒）。 區別是：前臺執行緒的程式，必須等所有的前臺執行緒執行完畢後才能