UnityThreading/UnityThread.cs at master · Feynmen/UnityThreading · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
using System;
using System.Collections;
using System.Threading;
using UnityEngine;
using UnityThreading.Events;

namespace UnityThreading
{
    public class UnityThread
    {
        /// <summary>
        /// Main thread name
        /// </summary>
        public const string MAIN_THREAD_NAME = "MainUnityThread";

        private const string THREAD_PREFIX = "UnityThread#";
        private static int _threadId;

        private readonly object _mutex = new object();
        private readonly Thread _thread;
        private readonly Action _action;

        /// <summary>
        /// Thread completed event
        /// </summary>
        public event Action Completed;

        /// <summary>
        /// Thread aborted event
        /// </summary>
        public event Action Aborted;

        private bool _isAlive;

        /// <summary>
        /// Check is alive thread
        /// </summary>
        public bool IsAlive
        {
            private set
            {
                lock (_mutex)
                {
                    _isAlive = value;
                }
            }
            get
            {
                lock (_mutex)
                {
                    return _isAlive;
                }
            }
        }

        /// <summary>
        /// Create thread
        /// </summary>
        public UnityThread(Action action)
        {
            UnityEvents.Instance.AplicationQuit += Clear;
            _thread = new Thread(ThreadFunc)
            {
                Name = THREAD_PREFIX + _threadId++,
                IsBackground = true
            };
            lock (_mutex)
            {
                _action = action;
            }
        }

        public void Start()
        {
            IsAlive = true;
            UnityEvents.Instance.StartCoroutine(ThreadState());
            _thread.Start();
        }

        public void Abort()
        {
            UnityEvents.Instance.StopCoroutine(ThreadState());
            if (Aborted != null)
            {
                Aborted.Invoke();
            }
            Clear();
        }

        private IEnumerator ThreadState()
        {
            while (IsAlive)
            {
                yield return null;
            }
            if (Completed != null)
            {
                Completed.Invoke();
            }
            Clear();
        }

        private void ThreadFunc()
        {
            _action.Invoke();
            IsAlive = false;
        }

        private void Clear()
        {
            UnityEvents.Instance.AplicationQuit -= Clear;
            Aborted = null;
            Completed = null;
            if (_thread.IsAlive)
            {
                _thread.Abort();
                _thread.Join();
            }
            Debug.Log("Clear ThreadId " + _threadId);
        }
    }
}